
acl2.lisp,6270
(defvar *acl2-compiler-enabled*)*acl2-compiler-enabled*67,3198
(defun acl2-set-character-encoding ()acl2-set-character-encoding308,15326
(defun our-file-encoding (pathname ef-spec buffer length)our-file-encoding425,19748
(defconstant acl2::*the-live-state* 'acl2_invisible::|The Live State Itself|)acl2::*the-live-state*706,31094
(defvar acl2::*compiling-certified-file* nil)acl2::*compiling-certified-file*741,33454
(defun acl2::defconst-redeclare-error (name)acl2::defconst-redeclare-error743,33501
(defparameter acl2::*safe-mode-verified-p*acl2::*safe-mode-verified-p*764,34444
(defmacro acl2::defconst (name term &rest rst)acl2::defconst773,34737
(defvar acl2::*copy-of-common-lisp-symbols-from-main-lisp-package*)acl2::*copy-of-common-lisp-symbols-from-main-lisp-package*847,37631
(defvar acl2::*copy-of-common-lisp-specials-and-constants*)acl2::*copy-of-common-lisp-specials-and-constants*848,37699
(defvar acl2::*copy-of-acl2-version*)acl2::*copy-of-acl2-version*849,37759
(defconstant acl2::*acl2-files*acl2::*acl2-files*851,37798
(defparameter *compiled-file-extension**compiled-file-extension*969,41767
(defmacro initialize-state-globals ()initialize-state-globals979,42177
(defconstant *suppress-compile-build-time**suppress-compile-build-time*1039,44898
(defparameter *global-package-prefix* "ACL2_GLOBAL_")*global-package-prefix*1051,45286
(defparameter *1*-package-prefix* "ACL2_*1*_")*1*-package-prefix*1053,45341
(defun make-global-package (x)make-global-package1055,45389
(defun make-*1*-package (x)make-*1*-package1063,45642
(defconstant *main-lisp-package**main-lisp-package*1081,46201
(defconstant *main-lisp-package-name-raw**main-lisp-package-name-raw*1084,46267
(defparameter acl2::*initial-lisp-symbol-mark*acl2::*initial-lisp-symbol-mark*1107,47149
(defconstant *acl2-package* (find-package "ACL2"))*acl2-package*1118,47578
(defmacro with-redefinition-suppressed (&rest forms)with-redefinition-suppressed1148,48739
(defmacro with-warnings-suppressed (&rest forms)with-warnings-suppressed1184,50090
(defmacro with-more-warnings-suppressed (&rest forms)with-more-warnings-suppressed1231,51752
(defmacro with-suppression (&rest forms)with-suppression1266,52887
(defconstant acl2::*acl2-status-file*acl2::*acl2-status-file*1281,53517
(defun acl2::check-suitability-for-acl2 ()acl2::check-suitability-for-acl21285,53624
(defun note-compile-ok ()note-compile-ok1301,54146
(defvar *lisp-extension* "lisp")*lisp-extension*1332,55684
(defmacro our-with-compilation-unit (form)our-with-compilation-unit1368,57211
(defconstant *acl2-read-character-terminators**acl2-read-character-terminators*1397,58533
(defparameter *acl2-readtable**acl2-readtable*1432,59857
(defparameter *host-readtable**host-readtable*1438,60068
(defun set-new-dispatch-macro-character (char subchar fn)set-new-dispatch-macro-character1443,60241
(defun define-sharp-dot ()define-sharp-dot1504,63280
(defun define-sharp-comma ()define-sharp-comma1510,63376
(defun define-sharp-atsign ()define-sharp-atsign1516,63476
(defun define-sharp-bang ()define-sharp-bang1522,63582
(defun define-sharp-u ()define-sharp-u1528,63684
(defvar *old-character-reader**old-character-reader*1534,63780
(defun modify-acl2-readtable (do-all-changes)modify-acl2-readtable1537,63854
(defvar *reckless-acl2-readtable**reckless-acl2-readtable*1626,66601
(defvar *load-compiled-verbose* nil)*load-compiled-verbose*1643,67127
(defun load-compiled (filename &optional verbose)load-compiled1645,67165
(defun non-trivial-acl2-proclaims-file-p ()non-trivial-acl2-proclaims-file-p1896,77147
(defun compile-acl2 (&optional use-acl2-proclaims)compile-acl21912,77809
(defvar user::*fast-acl2-gcl-build* nil)user::*fast-acl2-gcl-build*2023,82445
(defun load-acl2 (&optional fast)load-acl22025,82487
(defparameter *acl2-panic-exit-status* nil)*acl2-panic-exit-status*2129,86611
(defun exit-lisp (&optional (status '0 status-p))exit-lisp2131,86656
(defconstant *slashable-array**slashable-array*2236,91391
(defconstant *suspiciously-first-numeric-array**suspiciously-first-numeric-array*2249,91838
(defconstant *suspiciously-first-hex-array**suspiciously-first-hex-array*2260,92174
(defconstant *base-10-array**base-10-array*2274,92595
(defconstant *hex-array**hex-array*2285,92873
(defconstant *letter-array**letter-array*2298,93222
(defmacro suspiciously-first-numeric-array (print-base)suspiciously-first-numeric-array2312,93701
(defmacro numeric-array (print-base)numeric-array2317,93866
(defconstant *char-code-backslash* (char-code #\\))*char-code-backslash*2322,93974
(defconstant *char-code-slash* (char-code #\/))*char-code-slash*2324,94027
(defconstant *char-code-double-gritch* (char-code #\"))*char-code-double-gritch*2326,94076
(defconstant *big-n-special-object* '(nil . nil))*big-n-special-object*2332,94332
(defconstant *number-of-return-values**number-of-return-values*2334,94383
(defconstant *boole-array**boole-array*2340,94485
(defconstant *mo-f* (make-symbol "F"))*mo-f*2378,95852
(defconstant *mo-h* (make-symbol "H"))*mo-h*2379,95891
(defconstant *mo-o* (make-symbol "O"))*mo-o*2380,95930
(defconstant *mf-old-caller* (make-symbol "OLD-CALLER"))*mf-old-caller*2385,96023
(defconstant *mf-start-hons* (make-symbol "START-HONS"))*mf-start-hons*2386,96080
(defconstant *mf-start-pons* (make-symbol "START-PONS"))*mf-start-pons*2387,96137
(defconstant *mf-start-bytes* (make-symbol "START-BYTES"))*mf-start-bytes*2388,96194
(defconstant *mf-ans* (make-symbol "ANS"))*mf-ans*2389,96253
(defconstant *mf-ans-p* (make-symbol "ANS-P"))*mf-ans-p*2390,96296
(defconstant *mf-ma* (make-symbol "MA"))*mf-ma*2391,96343
(defconstant *mf-args* (make-symbol "ARGS"))*mf-args*2392,96384
(defconstant *mf-2mmf* (make-symbol "MF-2MMF"))*mf-2mmf*2393,96429
(defconstant *mf-2mmf-fnn* (make-symbol "MF-2MMF-FNN"))*mf-2mmf-fnn*2394,96477
(defconstant *mf-count-loc* (make-symbol "MF-COUNT-LOC"))*mf-count-loc*2395,96533
(defconstant *attached-fn-temp* (make-symbol "ATTACHED-FN-TEMP"))*attached-fn-temp*2397,96592
(defvar *debug-prompt-suffix* "")*debug-prompt-suffix*2424,97740
(defun break-level-for-acl2 (at &optional env)break-level-for-acl22426,97854

acl2-check.lisp,0

acl2-fns.lisp,5127
(defmacro qfuncall (fn &rest args)qfuncall27,1067
(defmacro defun-one-output (&rest args)defun-one-output40,1583
(defparameter *package-alist* nil)*package-alist*51,2044
(defun-one-output find-package-fast (string)find-package-fast53,2080
(defvar *global-symbol-key* (make-symbol "*GLOBAL-SYMBOL-KEY*"))*global-symbol-key*59,2287
(defun global-symbol (x)global-symbol61,2353
(defmacro live-state-p (x)live-state-p70,2692
(defun get-global (x state-state)get-global74,2771
(defmacro f-get-global (x st)f-get-global84,3106
(defun acl2-realp (x)acl2-realp117,4489
(defun gcl-version-> (major minor extra &optional weak)gcl-version->133,5032
(defun gcl-version->= (major minor extra)gcl-version->=158,6125
(defvar *do-proclaims**do-proclaims*225,9744
(defun macroexpand-till (form sym)macroexpand-till249,10778
(defun get-type-from-dcls (var dcls)get-type-from-dcls265,11486
(defun arg-declarations (formals dcls)arg-declarations273,11742
(defun collect-types (l)collect-types278,11927
(defun convert-type-to-integer-pair (typ)convert-type-to-integer-pair289,12266
(defvar *acl2-output-type-abort* nil)*acl2-output-type-abort*303,12700
(defun min-integer-* (x y)min-integer-*305,12739
(defun max-integer-* (x y)max-integer-*310,12845
(defun max-output-type-for-declare-form (type1 type2)max-output-type-for-declare-form315,12951
(defun max-output-type-for-declare-form-lst (type-list1 type-list2)max-output-type-for-declare-form-lst395,15907
(defun output-type-for-declare-form-rec (form flet-alist)output-type-for-declare-form-rec430,17321
(defun output-type-for-declare-form-rec-list (forms flet-alist)output-type-for-declare-form-rec-list572,23273
(defun output-type-for-declare-form (fn form)output-type-for-declare-form583,23767
(defun make-defun-declare-form (fn formmake-defun-declare-form629,25516
(defun make-defconst-declare-form (form)make-defconst-declare-form662,26934
(defun make-defstobj-declare-form (form)make-defstobj-declare-form680,27568
(defmacro eval-or-print (form stream)eval-or-print711,28963
(defun proclaim-form (form &optional stream)proclaim-form719,29149
(defun proclaim-file (name &optional stream)proclaim-file765,30747
(defparameter *comma* (make-symbol "COMMA")*comma*817,33359
(defparameter *comma-atsign* (make-symbol "COMMA-ATSIGN")*comma-atsign*821,33525
(defparameter *backquote-counter* 0*backquote-counter*825,33719
(defun backquote (x)backquote832,34051
(defun backquote-lst (l)backquote-lst875,36229
(defun rev1@ (x acc)rev1@900,37100
(defun acl2-read-character-string (s acc)acl2-read-character-string910,37307
(defun acl2-character-reader (s c n)acl2-character-reader982,40390
(defvar *inside-sharp-dot-read* nil)*inside-sharp-dot-read*991,40708
(defvar *inhibit-sharp-comma-warning* nil)*inhibit-sharp-comma-warning*993,40746
(defvar *inside-sharp-u-read* nil)*inside-sharp-u-read*995,40790
(defun sharp-comma-read (stream char n)sharp-comma-read997,40826
(defun sharp-dot-read (stream char n)sharp-dot-read1008,41357
(defun sharp-bang-read (stream char n)sharp-bang-read1044,42891
(defun sharp-u-read (stream char n)sharp-u-read1067,43864
(defmacro sharp-atsign-read-er (str &rest format-args)sharp-atsign-read-er1098,45255
(defun sharp-atsign-read (stream char n)sharp-atsign-read1104,45510
(defvar *sharp-reader-array-size**sharp-reader-array-size*1151,47484
(defvar *sharp-reader-array**sharp-reader-array*1158,47672
(defvar *sharp-reader-array-size-multiplier**sharp-reader-array-size-multiplier*1161,47744
(defconstant *sharp-reader-max-array-size**sharp-reader-max-array-size*1168,47924
(defvar *sharp-reader-max-index**sharp-reader-max-index*1176,48176
(defun update-sharp-reader-max-index (index)update-sharp-reader-max-index1189,48843
(defun reckless-sharp-sharp-read (stream char arg)reckless-sharp-sharp-read1218,50028
(defun reckless-sharp-equal-read (stream char arg)reckless-sharp-equal-read1224,50188
(defmacro with-reckless-read (&rest forms)with-reckless-read1232,50520
(defun symbol-package-name (x)symbol-package-name1254,51402
(defmacro gv (fn args val)gv1286,52851
(defun getenv$-raw (string)getenv$-raw1309,53832
(defun get-os ()get-os1332,54655
(defmacro our-ignore-errors (x)our-ignore-errors1341,54869
(defmacro safe-open (&rest args)safe-open1345,54945
(defun our-truename (filename &optional namestringp)our-truename1348,55017
(defun our-pwd ()our-pwd1418,58112
(defun cancel-dot-dots (full-pathname)cancel-dot-dots1429,58500
(defun unix-full-pathname (name &optional extension)unix-full-pathname1437,58818
(defun our-user-homedir-pathname ()our-user-homedir-pathname1465,59833
(defun ser-cons-reader-macro (stream subchar arg)ser-cons-reader-macro1517,62109
(defun ser-hons-reader-macro (stream subchar arg)ser-hons-reader-macro1523,62386
(defmacro special-form-or-op-p (name)special-form-or-op-p1540,63276
(defvar *startup-package-name* "ACL2")*startup-package-name*1547,63500
(defmacro save-def (def-form)save-def1549,63540
(defmacro defg (&rest r)defg1574,64516
(defmacro defv (&rest r)defv1588,65010

init.lisp,0

acl2-init.lisp,4182
(defconstant *current-acl2-world-key**current-acl2-world-key*306,14371
(defun system-call (string arguments)system-call360,16578
(defun copy-acl2 (dir)copy-acl2435,18977
(defun our-probe-file (filename)our-probe-file452,19492
(defun copy-distribution (output-file source-directory target-directorycopy-distribution473,20234
(defun make-tags ()make-tags643,27955
(defvar *saved-build-date-lst*)*saved-build-date-lst*684,30082
(defvar *saved-mode*)*saved-mode*685,30114
(defun svn-revision-from-line (s)svn-revision-from-line687,30137
(defconstant *acl2-svn-revision-string**acl2-svn-revision-string*698,30541
(defvar *saved-string**saved-string*726,31884
(defun maybe-load-acl2-init ()maybe-load-acl2-init754,32947
(defun chmod-executable (sysout-name)chmod-executable760,33145
(defun saved-build-dates (separator)saved-build-dates763,33233
(defmacro our-with-standard-io-syntax (&rest args)our-with-standard-io-syntax780,33835
(defun user-args-string (inert-args &optional (separator '"--"))user-args-string785,33966
(defmacro write-exec-file (stream prefix string &rest args)write-exec-file801,34631
(defun proclaim-files (&optional outfilename infilename infile-optional-p)proclaim-files829,35770
(defun insert-string (s)insert-string880,37745
(defvar *saved-system-banner**saved-system-banner*885,37841
(defun save-acl2-in-akcl-aux (sysout-name gcl-exec-namesave-acl2-in-akcl-aux905,38678
(defun save-acl2-in-akcl (sysout-name gcl-exec-namesave-acl2-in-akcl957,41023
(defun save-exec-raw (sysout-name host-lisp-args inert-args)save-exec-raw1180,50255
(defvar *acl2-default-restart-complete* nil)*acl2-default-restart-complete*1186,50542
(defun fix-default-pathname-defaults ()fix-default-pathname-defaults1188,50588
(defvar *print-startup-banner**print-startup-banner*1212,51420
(defvar *lp-ever-entered-p* nil)*lp-ever-entered-p*1227,52097
(defun acl2-default-restart ()acl2-default-restart1229,52131
(defun cmulisp-restart ()cmulisp-restart1303,54523
(defun sbcl-restart ()sbcl-restart1310,54655
(defun save-acl2-in-lucid (sysout-name &optional mode)save-acl2-in-lucid1316,54789
(defun lispworks-save-exec-aux (sysout-name eventual-sysout-namelispworks-save-exec-aux1322,54985
(defun save-acl2-in-lispworks (sysout-name mode eventual-sysout-name)save-acl2-in-lispworks1419,59502
(defun save-exec-raw (sysout-name host-lisp-args inert-args)save-exec-raw1429,59871
(defun save-acl2-in-cmulisp-aux (sysout-name core-namesave-acl2-in-cmulisp-aux1438,60142
(defun save-acl2-in-cmulisp (sysout-name &optional mode core-name)save-acl2-in-cmulisp1500,62823
(defun save-exec-raw (sysout-name host-lisp-args inert-args)save-exec-raw1509,63148
(defvar *sbcl-dynamic-space-size**sbcl-dynamic-space-size*1514,63342
(defvar *sbcl-contrib-dir* nil)*sbcl-contrib-dir*1561,65894
(defun save-acl2-in-sbcl-aux (sysout-name core-namesave-acl2-in-sbcl-aux1564,65934
(defun save-acl2-in-sbcl (sysout-name &optional mode core-name)save-acl2-in-sbcl1656,70213
(defun save-exec-raw (sysout-name host-lisp-args toplevel-args inert-args)save-exec-raw1666,70572
(defun save-acl2-in-allegro-aux (sysout-name dxl-namesave-acl2-in-allegro-aux1673,70851
(defun save-acl2-in-allegro (sysout-name &optional mode dxl-name)save-acl2-in-allegro1729,73236
(defun save-exec-raw (sysout-name host-lisp-args inert-args)save-exec-raw1743,73716
(defun rc-filename (dir)rc-filename1747,73903
(defun write-acl2rc (dir)write-acl2rc1750,73968
(defun save-acl2-in-clisp-aux (sysout-name mem-name host-lisp-args inert-args)save-acl2-in-clisp-aux1769,74682
(defun save-acl2-in-clisp (sysout-name &optional mode mem-name)save-acl2-in-clisp1815,76662
(defun save-exec-raw (sysout-name host-lisp-args inert-args)save-exec-raw1824,76982
(defun save-acl2-in-ccl-aux (sysout-name core-namesave-acl2-in-ccl-aux1829,77173
(defun save-acl2-in-ccl (sysout-name &optional mode core-name)save-acl2-in-ccl1933,82211
(defun save-exec-raw (sysout-name host-lisp-args inert-args)save-exec-raw1939,82391
(defun save-acl2 (&optional mode other-infosave-acl21946,82727
(defun generate-acl2-proclaims ()generate-acl2-proclaims2006,84857

akcl-acl2-trace.lisp,663
(defmacro trace (&rest fns)trace36,1430
(defmacro untrace (&rest fns)untrace92,3486
(defun trace-ppr-gcl (direction x &aux (state *the-live-state*))trace-ppr-gcl100,3630
(defun trace-fix-entry-raw (name l)trace-fix-entry-raw132,4972
(defun trace-fix-entry (name l)trace-fix-entry148,5602
(defun trace-values (name)trace-values163,6141
(defun trace-values (name)trace-values173,6430
(defun make-nths (i n var)make-nths178,6515
(defun trace-fix-exit-raw (name l)trace-fix-exit-raw184,6637
(defun trace-fix-exit (name original-name l &aux (state *the-live-state*))trace-fix-exit199,7204
(defun trace-fix-cond (trace-spec)trace-fix-cond220,8176

allegro-acl2-trace.lisp,616
(defvar *trace-arglist*)*trace-arglist*52,2090
(defvar *trace-values*)*trace-values*54,2116
(defconst *trace-sublis* '((values . *trace-values*)*trace-sublis*56,2141
(defun trace-pre-process (lst)trace-pre-process101,4371
(defun trace-entry (name l)trace-entry129,5368
(defun trace-values (name)trace-values158,6478
(defun trace-values (name)trace-values168,6767
(defun make-nths (i n var)make-nths173,6852
(defun trace-exit (name original-name l &aux (state *the-live-state*))trace-exit179,6974
(defun traced-fns-lst (lst)traced-fns-lst215,8449
(defun trace-process (lst)trace-process218,8514

openmcl-acl2-trace.lisp,575
(defvar *trace-arglist*)*trace-arglist*56,2188
(defvar *trace-values*)*trace-values*58,2214
(defparameter *trace-sublis* '((values . *trace-values*)*trace-sublis*60,2239
(defun trace-pre-process (lst &aux (state *the-live-state*))trace-pre-process66,2516
(defun trace-entry (name l)trace-entry101,3869
(defun trace-values (name)trace-values126,5007
(defun trace-exit (name original-name l)trace-exit135,5321
(defun traced-fns-lst (lst)traced-fns-lst164,6651
(defun trace-process (lst)trace-process167,6716
(defun acl2-traced-fns ()acl2-traced-fns187,7620

axioms.lisp,111044
(acl2::defconst acl2::*common-lisp-symbols-from-main-lisp-package*acl2::*common-lisp-symbols-from-main-lisp-package*81,4294
(defconst *common-lisp-specials-and-constants**common-lisp-specials-and-constants*593,26922
(defconst *stobj-inline-declare**stobj-inline-declare*671,31242
(defmacro make-package-entry (&key name imports hidden-p book-pathmake-package-entry914,42484
(defmacro find-package-entry (name known-package-alist)find-package-entry955,44431
(defmacro package-entry-name (package-entry)package-entry-name958,44533
(defmacro package-entry-imports (package-entry)package-entry-imports961,44604
(defmacro package-entry-hidden-p (package-entry)package-entry-hidden-p964,44679
(defmacro package-entry-book-path (package-entry)package-entry-book-path967,44756
(defmacro package-entry-defpkg-event-form (package-entry)package-entry-defpkg-event-form970,44835
(defmacro package-entry-tterm (package-entry)package-entry-tterm973,44928
(defmacro find-non-hidden-package-entry (name known-package-alist)find-non-hidden-package-entry976,45009
(defmacro remove-package-entry (name known-package-alist)remove-package-entry981,45202
(defmacro change-package-entry-hidden-p (entry value)change-package-entry-hidden-p984,45313
(defmacro getprop (symb key default world-name world-alist)getprop994,45683
(defvar *user-stobj-alist* nil)*user-stobj-alist*1012,46394
(defparameter *wormholep* nil)*wormholep*1041,48186
(defun-one-output replace-bad-lisp-object (x)replace-bad-lisp-object1048,48497
(defun-one-output replace-bad-lisp-object-list (x)replace-bad-lisp-object-list1060,48818
(defun-one-output wormhole-er (fn args)wormhole-er1066,48991
(defparameter *wormhole-cleanup-form* nil)*wormhole-cleanup-form*1079,49517
(defun-one-output cloaked-set-w! (x state)cloaked-set-w!1127,52541
(defun-one-output assoc-eq-butlast-2 (x alist)assoc-eq-butlast-21135,52817
(defun-one-output assoc-eq-equal-butlast-2 (x y alist)assoc-eq-equal-butlast-21146,53239
(defun-one-output push-wormhole-undo-formi (op arg1 arg2)push-wormhole-undo-formi1159,53746
(defconstant *open-input-channel-key**open-input-channel-key*1283,60510
(defconstant *open-input-channel-type-key**open-input-channel-type-key*1289,60725
(defconstant *open-output-channel-key**open-output-channel-key*1292,60819
(defconstant *open-output-channel-type-key**open-output-channel-type-key*1295,60905
(defconstant *non-existent-stream**non-existent-stream*1298,61001
(defvar *acl2-error-p* nil)*acl2-error-p*1304,61195
(defun interface-er (&rest args)interface-er1306,61224
(defun-one-output acl2-numberp (x)acl2-numberp1416,65177
(defun-one-output binary-+ (x y) (+ x y))binary-+1419,65228
(defun-one-output binary-* (x y) (* x y))binary-*1421,65271
(defun-one-output unary-- (x) (- x))unary--1423,65314
(defun-one-output unary-/ (x) (/ x))unary-/1425,65352
(defparameter *in-recover-world-flg* nil)*in-recover-world-flg*1431,65567
(defparameter *ever-known-package-alist**ever-known-package-alist*1436,65754
(defvar **1*-symbol-key* (make-symbol "**1*-SYMBOL-KEY*"))**1*-symbol-key*1459,66752
(defun *1*-symbol (x)*1*-symbol1461,66812
(defun *1*-symbol? (x)*1*-symbol?1471,67176
(defmacro defun-*1* (fn &rest args)defun-*1*1483,67657
(defparameter *defun-overrides* nil)*defun-overrides*1486,67730
(defmacro defun-overrides (name formals &rest rest)defun-overrides1488,67768
(defmacro defpkg (&whole event-form name importsdefpkg1503,68340
(defmacro defuns (&rest lst)defuns1516,68821
(defmacro defun-std (name formals &rest args)defun-std1521,68951
(defmacro defuns-std (&rest args)defuns-std1529,69177
(defmacro defthm (&rest args)defthm1532,69232
(defmacro defthmd (&rest args)defthmd1536,69296
(defmacro defthm-std (&rest args)defthm-std1541,69386
(defmacro defaxiom (&rest args)defaxiom1545,69454
(defmacro skip-proofs (arg)skip-proofs1549,69520
(defmacro deflabel (&rest args)deflabel1552,69556
(defmacro defdoc (&rest args)defdoc1556,69622
(defmacro deftheory (&rest args)deftheory1560,69686
(defun-one-output stobj-initial-statep-arr (n i arr init)stobj-initial-statep-arr1564,69753
(defun-one-output stobj-initial-statep-entry (temp entry)stobj-initial-statep-entry1569,69926
(defun-one-output stobj-initial-statep1 (field-templates ndx stobj)stobj-initial-statep11599,70846
(defun-one-output stobj-initial-statep (stobj field-templates)stobj-initial-statep1607,71237
(defun remove-stobj-inline-declare (x)remove-stobj-inline-declare1621,71820
(defun congruent-stobj-rep-raw (name)congruent-stobj-rep-raw1628,72031
(defmacro defstobj (name &rest args)defstobj1640,72416
(defmacro value-triple (&rest args)value-triple1766,77913
(defmacro verify-termination-boot-strap (&rest args)verify-termination-boot-strap1770,77983
(defmacro verify-guards (&rest args)verify-guards1774,78070
(defmacro in-theory (&rest args)in-theory1778,78141
(defmacro in-arithmetic-theory (&rest args)in-arithmetic-theory1782,78208
(defmacro regenerate-tau-database (&rest args)regenerate-tau-database1786,78286
(defmacro push-untouchable (&rest args)push-untouchable1790,78367
(defmacro remove-untouchable (&rest args)remove-untouchable1794,78441
(defmacro set-body (&rest args)set-body1798,78517
(defmacro table (&rest args)table1802,78583
(defmacro encapsulate (signatures &rest lst)encapsulate1813,78960
(defparameter *inside-include-book-fn**inside-include-book-fn*1856,80764
(defmacro include-book (user-book-nameinclude-book1867,81214
(defmacro certify-book (&rest args)certify-book1881,81781
(defmacro local (x)local1892,82282
(defmacro defchoose (&rest args)defchoose1896,82333
(defmacro mutual-recursion (&rest lst)mutual-recursion1906,82748
(defmacro make-event (&whole event-formmake-event1909,82809
(deflabel programmingprogramming1929,83792
(deflabel acl2-built-insacl2-built-ins1946,84413
(deflabel miscellaneousmiscellaneous1962,85124
(defconst *standard-co* 'acl2-output-channel::standard-character-output-0)*standard-co*1976,85499
(defconst *standard-oi* 'acl2-input-channel::standard-object-input-0)*standard-oi*1978,85575
(defconst *standard-ci* 'acl2-input-channel::standard-character-input-0)*standard-ci*1980,85646
(defconst nil 'nilnil2002,86101
(defconst t 'tt2010,86269
(defun insist (x)insist2016,86422
(defun iff (p q)iff2025,86649
(defun xor (p q)xor2040,87041
(defun eq (x y)eq2055,87409
(defun booleanp (x)booleanp2082,88527
(defthm iff-is-an-equivalenceiff-is-an-equivalence2104,89117
(defun implies (p q)implies2112,89332
(defthm iff-implies-equal-implies-1iff-implies-equal-implies-12127,89706
(defthm iff-implies-equal-implies-2iff-implies-equal-implies-22132,89855
(defun not (p)not2138,90021
(defthm iff-implies-equal-notiff-implies-equal-not2155,90437
(defun hide (x)hide2160,90568
(defun rewrite-equiv (x)rewrite-equiv2266,95213
(defmacro real/rationalp (x)real/rationalp2280,95699
(defmacro complex/complex-rationalp (x)complex/complex-rationalp2298,96323
(defun true-listp (x)true-listp2320,97133
(defun list-macro (lst)list-macro2336,97523
(defmacro list (&rest args)list2345,97724
(defun and-macro (lst)and-macro2360,98128
(defmacro and (&rest args)and2371,98360
(defun or-macro (lst)or-macro2387,98803
(defmacro or (&rest args)or2399,99057
(defmacro - (x &optional (y 'nil binary-casep))-2442,100156
(defthm booleanp-compound-recognizerbooleanp-compound-recognizer2487,102017
(defun integer-abs (x)integer-abs2501,102512
(defun xxxjoin (fn args)xxxjoin2507,102621
(defmacro + (&rest rst)+2526,103142
(defun-one-output len2 (x acc)len22537,103401
(defun len1 (x acc)len12542,103511
(defun len (x)len2571,104808
(defun length (x)length2600,105600
(defun-one-output complex-rationalp (x)complex-rationalp2624,106244
(defun acl2-count (x)acl2-count2627,106301
(defun cond-clausesp (clauses)cond-clausesp2682,108448
(defun cond-macro (clauses)cond-macro2691,108704
(defmacro cond (&rest clauses)cond2718,109701
(defun eqlablep (x)eqlablep2740,110426
(defthm eqlablep-recogeqlablep-recog2764,111304
(defun eqlable-listp (l)eqlable-listp2773,111505
(defun eql (x y)eql2791,111988
(defun atom (x)atom2814,112706
(defun make-character-list (x)make-character-list2833,113169
(defun eqlable-alistp (x)eqlable-alistp2855,113752
(defun alistp (l)alistp2873,114302
(defthm alistp-forward-to-true-listpalistp-forward-to-true-listp2889,114695
(defthm eqlable-alistp-forward-to-alistpeqlable-alistp-forward-to-alistp2894,114817
(defun acons (key datum alist)acons2900,114964
(defun endp (x)endp2919,115537
(defmacro caar (x)caar2943,116253
(defmacro cadr (x)cadr2952,116443
(defmacro cdar (x)cdar2961,116633
(defmacro cddr (x)cddr2970,116823
(defmacro caaar (x)caaar2979,117013
(defmacro caadr (x)caadr2988,117206
(defmacro cadar (x)cadar2997,117399
(defmacro caddr (x)caddr3006,117592
(defmacro cdaar (x)cdaar3015,117785
(defmacro cdadr (x)cdadr3024,117978
(defmacro cddar (x)cddar3033,118171
(defmacro cdddr (x)cdddr3042,118364
(defmacro caaaar (x)caaaar3051,118557
(defmacro caaadr (x)caaadr3060,118753
(defmacro caadar (x)caadar3069,118949
(defmacro caaddr (x)caaddr3078,119145
(defmacro cadaar (x)cadaar3087,119341
(defmacro cadadr (x)cadadr3096,119537
(defmacro caddar (x)caddar3105,119733
(defmacro cadddr (x)cadddr3114,119929
(defmacro cdaaar (x)cdaaar3123,120125
(defmacro cdaadr (x)cdaadr3132,120321
(defmacro cdadar (x)cdadar3141,120517
(defmacro cdaddr (x)cdaddr3150,120713
(defmacro cddaar (x)cddaar3159,120909
(defmacro cddadr (x)cddadr3168,121105
(defmacro cdddar (x)cdddar3177,121301
(defmacro cddddr (x)cddddr3186,121497
(defun null (x)null3195,121693
(defun symbol-listp (lst)symbol-listp3213,122205
(defthm symbol-listp-forward-to-true-listpsymbol-listp-forward-to-true-listp3229,122623
(defun symbol-doublet-listp (lst)symbol-doublet-listp3234,122757
(defun reverse-strip-cars (x a)reverse-strip-cars3361,127283
(defun strip-cars (x)strip-cars3367,127472
(defun reverse-strip-cdrs (x a)reverse-strip-cdrs3392,128222
(defun strip-cdrs (x)strip-cdrs3398,128411
(defmacro let-mbe (bindings &key logic exec)let-mbe3422,129152
(defun return-last (fn eager-arg last-arg)return-last3428,129282
(defmacro return-last (qfn arg2 arg3)return-last3942,151401
(defmacro mbe1-raw (exec logic)mbe1-raw3990,153535
(defmacro mbe1 (exec logic)mbe13998,153737
(defmacro must-be-equal (logic exec)must-be-equal4017,154305
(defmacro mbe (&key (exec 'nil exec-p) (logic 'nil logic-p))mbe4045,155567
(defmacro mbt (x)mbt4188,161590
(defdoc equality-variantsequality-variants4291,165761
(defdoc equality-variants-detailsequality-variants-details4404,171416
(defun member-eq-exec (x lst)member-eq-exec4587,178312
(defun member-eql-exec (x lst)member-eql-exec4595,178578
(defun member-equal (x lst)member-equal4603,178849
(defmacro member-eq (x lst)member-eq4612,179151
(defthm member-eq-exec-is-member-equalmember-eq-exec-is-member-equal4615,179211
(defthm member-eql-exec-is-member-equalmember-eql-exec-is-member-equal4619,179311
(defmacro member (x l &key (test ''eql))member4624,179430
(defun subsetp-eq-exec (x y)subsetp-eq-exec4679,181496
(defun subsetp-eql-exec (x y)subsetp-eql-exec4690,181855
(defun subsetp-equal (x y)subsetp-equal4702,182205
(defmacro subsetp-eq (x y)subsetp-eq4713,182560
(defthm subsetp-eq-exec-is-subsetp-equalsubsetp-eq-exec-is-subsetp-equal4716,182618
(defthm subsetp-eql-exec-is-subsetp-equalsubsetp-eql-exec-is-subsetp-equal4720,182722
(defmacro subsetp (x y &key (test ''eql))subsetp4725,182845
(defun symbol-alistp (x)symbol-alistp4776,184799
(defthm symbol-alistp-forward-to-eqlable-alistpsymbol-alistp-forward-to-eqlable-alistp4793,185300
(defun assoc-eq-exec (x alist)assoc-eq-exec4800,185453
(defun assoc-eql-exec (x alist)assoc-eql-exec4808,185740
(defun assoc-equal (x alist)assoc-equal4816,186032
(defmacro assoc-eq (x lst)assoc-eq4825,186348
(defthm assoc-eq-exec-is-assoc-equalassoc-eq-exec-is-assoc-equal4828,186406
(defthm assoc-eql-exec-is-assoc-equalassoc-eql-exec-is-assoc-equal4832,186502
(defmacro assoc (x alist &key (test ''eql))assoc4837,186617
(defun assoc-eq-equal-alistp (x)assoc-eq-equal-alistp4890,188728
(defun assoc-eq-equal (x y alist)assoc-eq-equal4898,188983
(defmacro <= (x y)<=4918,189730
(defun = (x y)=4933,190062
(defun /= (x y)/=4958,190716
(defmacro > (x y)>4982,191419
(defmacro >= (x y)>=4997,191723
(deflabel zero-test-idiomszero-test-idioms5011,192041
(defmacro int= (i j)int=5180,200454
(defun zp (x)zp5202,201199
(defun-one-output zp (x)zp5242,202449
(defthm zp-compound-recognizerzp-compound-recognizer5246,202518
(defthm zp-openzp-open5261,203000
(defun zip (x)zip5288,203862
(defun-one-output zip (x) (= x 0))zip5328,205038
(defthm zip-compound-recognizerzip-compound-recognizer5330,205074
(defthm zip-openzip-open5339,205269
(defun nth (n l)nth5348,205477
(defun char (s n)char5375,206230
(defun proper-consp (x)proper-consp5399,206962
(defun improper-consp (x)improper-consp5414,207355
(defmacro * (&rest rst)*5431,207814
(defun conjugate (x)conjugate5460,208479
(defmacro prog2$ (x y)prog2$5481,209030
(deflabel OtherOther5558,211949
(deflabel acl2-helpacl2-help5568,212251
(defmacro ec-call1-raw (ign x)ec-call1-raw5581,212678
(defmacro ec-call1 (ign x)ec-call15615,214378
(defmacro ec-call (x)ec-call5623,214653
(defmacro non-exec (x)non-exec5770,220482
(defmacro / (x &optional (y 'nil binary-casep))/5868,223535
(defaxiom closureclosure5906,224432
(defaxiom Associativity-of-+Associativity-of-+5913,224589
(defaxiom Commutativity-of-+Commutativity-of-+5916,224658
(defun fix (x)fix5919,224715
(defaxiom Unicity-of-0Unicity-of-05939,225217
(defaxiom Inverse-of-+Inverse-of-+5943,225277
(defaxiom Associativity-of-*Associativity-of-*5946,225326
(defaxiom Commutativity-of-*Commutativity-of-*5949,225395
(defaxiom Unicity-of-1Unicity-of-15952,225452
(defaxiom Inverse-of-*Inverse-of-*5956,225512
(defaxiom DistributivityDistributivity5961,225639
(defaxiom <-on-others<-on-others5965,225719
(defaxiom ZeroZero5970,225808
(defaxiom TrichotomyTrichotomy5974,225861
(defaxiom PositivePositive5986,226131
(defaxiom Rational-implies1Rational-implies15996,226412
(defaxiom Rational-implies2Rational-implies26003,226611
(defaxiom integer-implies-rationalinteger-implies-rational6011,226844
(defaxiom rational-implies-realrational-implies-real6016,226965
(defaxiom complex-implies1complex-implies16022,227114
(defaxiom complex-definitioncomplex-definition6029,227298
(defaxiom nonzero-imagpartnonzero-imagpart6040,227635
(defaxiom realpart-imagpart-elimrealpart-imagpart-elim6045,227766
(defaxiom realpart-complexrealpart-complex6054,228053
(defaxiom imagpart-compleximagpart-complex6062,228283
(defthm complex-equalcomplex-equal6070,228507
(defun force (x)force6089,229215
(defconst *force-xnume**force-xnume*6228,237055
(defun immediate-force-modep ()immediate-force-modep6235,237176
(defconst *immediate-force-modep-xnume**immediate-force-modep-xnume*6284,239081
(defun case-split (x)case-split6287,239145
(defmacro disable-forcing nildisable-forcing6349,241713
(defmacro enable-forcing nilenable-forcing6372,242460
(defmacro disable-immediate-force-modep ()disable-immediate-force-modep6397,243258
(defmacro enable-immediate-force-modep ()enable-immediate-force-modep6423,244196
(defun synp (vars form term)synp6449,245120
(defmacro syntaxp (form)syntaxp6485,246766
(deflabel syntaxp-examplessyntaxp-examples6715,257753
(defmacro bind-free (form &optional (vars))bind-free6918,264265
(deflabel bind-free-examplesbind-free-examples7221,277543
(defun extra-info (x y)extra-info7408,284547
(defconst *extra-info-fn**extra-info-fn*7415,284709
(deflabel rule-classesrule-classes7430,285381
(defun tau-system (x)tau-system7723,303021
(defconst *tau-status-boot-strap-settings**tau-status-boot-strap-settings*8165,323041
(defconst *tau-system-xnume**tau-system-xnume*8184,324024
(defconst *tau-acl2-numberp-pair* '(0 . ACL2-NUMBERP))*tau-acl2-numberp-pair*8188,324149
(defconst *tau-integerp-pair**tau-integerp-pair*8189,324204
(defconst *tau-rationalp-pair**tau-rationalp-pair*8194,324323
(defconst *tau-natp-pair**tau-natp-pair*8199,324445
(defconst *tau-posp-pair**tau-posp-pair*8204,324554
(defconst *tau-minusp-pair**tau-minusp-pair*8209,324663
(defconst *tau-booleanp-pair**tau-booleanp-pair*8214,324778
(defaxiom nonnegative-productnonnegative-product8238,325747
(defaxiom Integer-0Integer-08268,326743
(defaxiom Integer-1Integer-18272,326800
(defaxiom Integer-stepInteger-step8276,326857
(defaxiom Lowest-TermsLowest-Terms8282,326999
(defthm basic-tau-rulesbasic-tau-rules8310,328045
(defaxiom car-cdr-elimcar-cdr-elim8363,329881
(defaxiom car-cons (equal (car (cons x y)) x))car-cons8368,329994
(defaxiom cdr-cons (equal (cdr (cons x y)) y))cdr-cons8370,330042
(defaxiom cons-equalcons-equal8372,330090
(defaxiom booleanp-characterpbooleanp-characterp8385,330495
(defaxiom characterp-pagecharacterp-page8389,330575
(defaxiom characterp-tabcharacterp-tab8393,330645
(defaxiom characterp-ruboutcharacterp-rubout8397,330713
(defun no-duplicatesp-eq-exec (l)no-duplicatesp-eq-exec8403,330805
(defun no-duplicatesp-eql-exec (l)no-duplicatesp-eql-exec8409,330994
(defun no-duplicatesp-equal (l)no-duplicatesp-equal8415,331183
(defmacro no-duplicatesp-eq (x)no-duplicatesp-eq8421,331369
(defthm no-duplicatesp-eq-exec-is-no-duplicatesp-equalno-duplicatesp-eq-exec-is-no-duplicatesp-equal8424,331436
(defthm no-duplicatesp-eql-exec-is-no-duplicatesp-equalno-duplicatesp-eql-exec-is-no-duplicatesp-equal8428,331564
(defmacro no-duplicatesp (x &key (test ''eql))no-duplicatesp8432,331694
(defun chk-no-duplicatesp (lst)chk-no-duplicatesp8484,333593
(defun r-eqlable-alistp (x)r-eqlable-alistp8492,333771
(defun r-symbol-alistp (x)r-symbol-alistp8512,334360
(defun rassoc-eq-exec (x alist)rassoc-eq-exec8531,334904
(defun rassoc-eql-exec (x alist)rassoc-eql-exec8539,335195
(defun rassoc-equal (x alist)rassoc-equal8547,335491
(defmacro rassoc-eq (x alist)rassoc-eq8556,335810
(defthm rassoc-eq-exec-is-rassoc-equalrassoc-eq-exec-is-rassoc-equal8559,335874
(defthm rassoc-eql-exec-is-rassoc-equalrassoc-eql-exec-is-rassoc-equal8563,335982
(defmacro rassoc (x alist &key (test ''eql))rassoc8568,336109
(defconst *standard-chars**standard-chars*8624,338451
(defun standard-char-p (x)standard-char-p8634,338920
(defun standard-char-listp (l)standard-char-listp8660,339706
(defun character-listp (l)character-listp8682,340308
(defthm character-listp-forward-to-eqlable-listpcharacter-listp-forward-to-eqlable-listp8698,340729
(defthm standard-char-listp-forward-to-character-listpstandard-char-listp-forward-to-character-listp8703,340875
(defaxiom coerce-inverse-1coerce-inverse-18708,341033
(defaxiom coerce-inverse-2coerce-inverse-28737,342065
(defaxiom character-listp-coercecharacter-listp-coerce8747,342366
(defun string (x)string8779,343796
(defun alpha-char-p (x)alpha-char-p8817,345081
(defun upper-case-p (x)upper-case-p8845,346041
(defun lower-case-p (x)lower-case-p8874,347084
(defun char-upcase (x)char-upcase8903,348126
(defun char-downcase (x)char-downcase8959,350090
(defthm lower-case-p-char-downcaselower-case-p-char-downcase9014,352105
(defthm upper-case-p-char-upcaseupper-case-p-char-upcase9019,352252
(defthm lower-case-p-forward-to-alpha-char-plower-case-p-forward-to-alpha-char-p9024,352395
(defthm upper-case-p-forward-to-alpha-char-pupper-case-p-forward-to-alpha-char-p9030,352570
(defthm alpha-char-p-forward-to-characterpalpha-char-p-forward-to-characterp9036,352745
(defthm characterp-char-downcasecharacterp-char-downcase9041,352879
(defthm characterp-char-upcasecharacterp-char-upcase9045,352982
(defun string-downcase1 (l)string-downcase19054,353307
(defthm character-listp-string-downcase-1character-listp-string-downcase-19063,353586
(defun string-downcase (x)string-downcase9067,353688
(defun string-upcase1 (l)string-upcase19094,354668
(defthm character-listp-string-upcase1-1character-listp-string-upcase1-19103,354941
(defun string-upcase (x)string-upcase9107,355040
(defun our-digit-char-p (ch radix)our-digit-char-p9128,355755
(defmacro digit-char-p (ch &optional (radix '10))digit-char-p9201,358006
(defun char-equal (x y)char-equal9224,358906
(defun atom-listp (lst)atom-listp9248,359698
(defthm atom-listp-forward-to-true-listpatom-listp-forward-to-true-listp9266,360158
(defthm eqlable-listp-forward-to-atom-listpeqlable-listp-forward-to-atom-listp9271,360288
(defun good-atom-listp (lst)good-atom-listp9276,360424
(defthm good-atom-listp-forward-to-atom-listpgood-atom-listp-forward-to-atom-listp9300,361139
(defthm characterp-nthcharacterp-nth9305,361279
(defun ifix (x)ifix9311,361431
(defun rfix (x)rfix9330,361944
(defun realfix (x)realfix9359,362998
(defun nfix (x)nfix9378,363525
(defun string-equal1 (str1 str2 i maximum)string-equal19399,364089
(defun string-equal (str1 str2)string-equal9424,365012
(defun standard-string-alistp (x)standard-string-alistp9451,365996
(defthm standard-string-alistp-forward-to-alistpstandard-string-alistp-forward-to-alistp9472,366712
(defun assoc-string-equal (str alist)assoc-string-equal9477,366858
(defdoc e0-ordinalpe0-ordinalp9513,368184
(defdoc e0-ord-<e0-ord-<9530,368986
(defun natp (x)natp9547,369802
(defthm natp-compound-recognizernatp-compound-recognizer9566,370456
(defun posp (x)posp9572,370598
(defthm posp-compound-recognizerposp-compound-recognizer9589,371177
(defun o-finp (x)o-finp9595,371318
(defmacro o-infp (x)o-infp9610,371809
(defun o-first-expt (x)o-first-expt9620,372028
(defun o-first-coeff (x)o-first-coeff9640,372715
(defun o-rst (x)o-rst9660,373423
(defun o<g (x)o<g9677,374083
(defun o< (x y)o<9689,374349
(defmacro o> (x y)o>9764,378142
(defmacro o<= (x y)o<=9773,378338
(defmacro o>= (x y)o>=9782,378555
(defun o-p (x)o-p9791,378775
(defthm o-p-implies-o<go-p-implies-o<g9976,385860
(defun make-ord (fe fco rst)make-ord9982,385946
(defun list*-macro (lst)list*-macro10021,387333
(defmacro list* (&rest args)list*10031,387610
(defmacro throw-without-attach (ignored-attachment fn formals)throw-without-attach10050,388083
(defvar *aokp**aokp*10057,388318
(defmacro aokp ()aokp10064,388490
(defvar *attached-fn-called* nil)*attached-fn-called*10068,388527
(defmacro update-attached-fn-called (fn)update-attached-fn-called10071,388569
(defmacro throw-or-attach (fn formals &optional *1*-p)throw-or-attach10075,388687
(defun throw-or-attach-call (fn formals)throw-or-attach-call10103,389804
(defun null-body-er (fn formals maybe-attach)null-body-er10147,391623
(defconst *main-lisp-package-name**main-lisp-package-name*10169,392754
(defconst *initial-known-package-alist**initial-known-package-alist*10184,393439
(defaxiom stringp-symbol-package-namestringp-symbol-package-name10205,394456
(defaxiom symbolp-intern-in-package-of-symbolsymbolp-intern-in-package-of-symbol10209,394567
(defaxiom symbolp-pkg-witnesssymbolp-pkg-witness10213,394696
(defparameter *ld-level**ld-level*10218,394808
(defvar *hard-error-returns-nilp* nil)*hard-error-returns-nilp*10251,396626
(defun-one-output throw-raw-ev-fncall (val)throw-raw-ev-fncall10254,396683
(defun hard-error (ctx str alist)hard-error10275,397471
(defun illegal (ctx str alist)illegal10392,402919
(defmacro intern (x y)intern10460,405728
(defmacro intern$ (x y)intern$10527,408726
(defun keywordp (x)keywordp10548,409429
(defthm keywordp-forward-to-symbolpkeywordp-forward-to-symbolp10577,410231
(defaxiom intern-in-package-of-symbol-symbol-nameintern-in-package-of-symbol-symbol-name10582,410351
(defthm symbol-package-name-of-symbol-is-not-empty-stringsymbol-package-name-of-symbol-is-not-empty-string10595,411011
(defconst *pkg-witness-name* "ACL2-PKG-WITNESS")*pkg-witness-name*10611,411806
(defaxiom symbol-name-pkg-witnesssymbol-name-pkg-witness10613,411856
(defaxiom symbol-package-name-pkg-witness-namesymbol-package-name-pkg-witness-name10617,411967
(defun member-symbol-name (str l)member-symbol-name10634,412629
(defthm symbol-equalitysymbol-equality10643,412902
(defaxiom symbol-name-intern-in-package-of-symbolsymbol-name-intern-in-package-of-symbol10663,413573
(defaxiom symbol-package-name-intern-in-package-of-symbolsymbol-package-name-intern-in-package-of-symbol10668,413770
(defaxiom intern-in-package-of-symbol-is-identityintern-in-package-of-symbol-is-identity10677,414132
(defaxiom symbol-listp-pkg-importssymbol-listp-pkg-imports10688,414539
(defaxiom no-duplicatesp-eq-pkg-importsno-duplicatesp-eq-pkg-imports10692,414684
(defaxiom completion-of-pkg-importscompletion-of-pkg-imports10696,414791
(defaxiom acl2-input-channel-packageacl2-input-channel-package10709,415194
(defaxiom acl2-output-channel-packageacl2-output-channel-package10713,415291
(defaxiom acl2-packageacl2-package10717,415390
(defaxiom keyword-packagekeyword-package10721,415500
(defaxiom string-is-not-circularstring-is-not-circular10729,415739
(defaxiom nil-is-not-circularnil-is-not-circular10737,416068
(defun-one-output intern-in-package-of-symbol (str sym)intern-in-package-of-symbol10772,417716
(defdoc pkg-importspkg-imports10809,419573
(defun-one-output pkg-imports (pkg)pkg-imports10865,421950
(defdoc pkg-witnesspkg-witness10873,422316
(defun-one-output pkg-witness (pkg)pkg-witness10890,423056
(defun binary-append (x y)binary-append10908,423752
(defmacro append (&rest rst)append10927,424232
(defthm true-listp-appendtrue-listp-append10948,425059
(defthm standard-char-listp-appendstandard-char-listp-append10978,425919
(defthm character-listp-appendcharacter-listp-append10985,426192
(defthm append-to-nilappend-to-nil10991,426389
(defmacro concatenate (result-type &rest sequences)concatenate10997,426511
(defun string-append (str1 str2)string-append11052,428841
(defun string-listp (x)string-listp11088,430054
(defun string-append-lst (x)string-append-lst11107,430455
(defmacro 1+ (x)1+11120,430817
(defmacro 1- (x)1-11134,431079
(defun remove-eq-exec (x l)remove-eq-exec11149,431334
(defun remove-eql-exec (x l)remove-eql-exec11158,431635
(defun remove-equal (x l)remove-equal11167,431942
(defmacro remove-eq (x lst)remove-eq11177,432274
(defthm remove-eq-exec-is-remove-equalremove-eq-exec-is-remove-equal11180,432334
(defthm remove-eql-exec-is-remove-equalremove-eql-exec-is-remove-equal11184,432434
(defmacro remove (x l &key (test ''eql))remove11189,432553
(defun remove1-eq-exec (x l)remove1-eq-exec11247,434664
(defun remove1-eql-exec (x l)remove1-eql-exec11256,434948
(defun remove1-equal (x l)remove1-equal11265,435237
(defmacro remove1-eq (x lst)remove1-eq11272,435430
(defthm remove1-eq-exec-is-remove1-equalremove1-eq-exec-is-remove1-equal11275,435492
(defthm remove1-eql-exec-is-remove1-equalremove1-eql-exec-is-remove1-equal11279,435596
(defmacro remove1 (x l &key (test ''eql))remove111283,435702
(deflabel pairlispairlis11336,437751
(defun pairlis$ (x y)pairlis$11346,437991
(defun remove-duplicates-eq-exec (l)remove-duplicates-eq-exec11374,438995
(defun remove-duplicates-eql-exec (l)remove-duplicates-eql-exec11381,439232
(defun remove-duplicates-equal (l)remove-duplicates-equal11388,439470
(defmacro remove-duplicates-eq (x)remove-duplicates-eq11395,439702
(defthm remove-duplicates-eq-exec-is-remove-duplicates-equalremove-duplicates-eq-exec-is-remove-duplicates-equal11398,439775
(defthm remove-duplicates-eql-exec-is-remove-duplicates-equalremove-duplicates-eql-exec-is-remove-duplicates-equal11402,439915
(defmacro remove-duplicates-logic (x)remove-duplicates-logic11406,440057
(defmacro remove-duplicates (x &key (test ''eql))remove-duplicates11414,440275
(defthm character-listp-remove-duplicatescharacter-listp-remove-duplicates11486,443322
(deflabel eventsevents11495,443679
(deflabel documentationdocumentation11526,445219
(deflabel historyhistory11725,453827
(defmacro first (x)first11752,455000
(defmacro second (x)second11761,455177
(defmacro third (x)third11770,455357
(defmacro fourth (x)fourth11779,455536
(defmacro fifth (x)fifth11788,455718
(defmacro sixth (x)sixth11797,455910
(defmacro seventh (x)seventh11806,456103
(defmacro eighth (x)eighth11815,456301
(defmacro ninth (x)ninth11824,456498
(defmacro tenth (x)tenth11833,456705
(defmacro rest (x)rest11842,456913
(defun identity (x) (declare (xargs :guard t))identity11856,457200
(defun revappend (x y)revappend11870,457499
(defthm character-listp-revappendcharacter-listp-revappend11904,458455
(defun reverse (x)reverse11915,458799
(defdoc switches-parameters-and-modesswitches-parameters-and-modes11938,459446
(defconst *valid-output-names**valid-output-names*11947,459775
(defun set-difference-eq-exec (l1 l2)set-difference-eq-exec11953,459932
(defun set-difference-eql-exec (l1 l2)set-difference-eql-exec11963,460342
(defun set-difference-equal (l1 l2)set-difference-equal11973,460754
(defmacro set-difference-eq (l1 l2)set-difference-eq11981,461056
(defthm set-difference-eq-exec-is-set-difference-equalset-difference-eq-exec-is-set-difference-equal11984,461133
(defthm set-difference-eql-exec-is-set-difference-equalset-difference-eql-exec-is-set-difference-equal11988,461269
(defmacro set-difference$ (l1 l2 &key (test ''eql))set-difference$11992,461407
(defun listp (x)listp12050,463801
(defconst *summary-types**summary-types*12070,464294
(defun with-output-fn (ctx args off on gag-mode off-on-p gag-p stackwith-output-fn12073,464398
(defun last (l)last12234,471605
(defun first-n-ac (i l ac)first-n-ac12263,472292
(defun take (n l)take12271,472547
(defun butlast (lst n)butlast12319,474045
(defmacro with-output (&rest args)with-output12360,475294
(defmacro with-output (&rest args)with-output12364,475368
(defun mutual-recursion-guardp (rst)mutual-recursion-guardp12541,482859
(defun collect-cadrs-when-car-eq (x alist)collect-cadrs-when-car-eq12550,483228
(defmacro value (x)value12558,483539
(defun value-triple-fn (form on-skip-proofs check)value-triple-fn12564,483615
(defmacro value-triple (form &key on-skip-proofs check)value-triple12591,484755
(defmacro assert-event (form &key on-skip-proofs msg)assert-event12633,486599
(defun xd-name (event-type name)xd-name12678,488628
(defun defund-name-list (defuns acc)defund-name-list12689,488975
(defun throw-nonexec-error (fn actuals)throw-nonexec-error12702,489421
(defun defun-nx-fn (form disabledp)defun-nx-fn12746,490935
(defmacro defun-nx (&whole form &rest rest)defun-nx12760,491455
(defmacro defund-nx (&whole form &rest rest)defund-nx12836,494568
(defun update-mutual-recursion-for-defun-nx-1 (defs)update-mutual-recursion-for-defun-nx-112842,494770
(defun update-mutual-recursion-for-defun-nx (defs)update-mutual-recursion-for-defun-nx12857,495359
(defmacro mutual-recursion (&whole event-form &rest rst)mutual-recursion12866,495678
(defun pseudo-termp (x)pseudo-termp13005,501305
(defun pseudo-term-listp (lst)pseudo-term-listp13088,505499
(defthm pseudo-term-listp-forward-to-true-listppseudo-term-listp-forward-to-true-listp13096,505691
(defun pseudo-term-list-listp (l)pseudo-term-list-listp13107,505983
(defun add-to-set-eq-exec (x lst)add-to-set-eq-exec13118,506218
(defun add-to-set-eql-exec (x lst)add-to-set-eql-exec13125,506448
(defun add-to-set-equal (x l)add-to-set-equal13132,506678
(defmacro add-to-set-eq (x lst)add-to-set-eq13145,507113
(defmacro add-to-set-eql (x lst)add-to-set-eql13150,507268
(defthm add-to-set-eq-exec-is-add-to-set-equaladd-to-set-eq-exec-is-add-to-set-equal13153,507338
(defthm add-to-set-eql-exec-is-add-to-set-equaladd-to-set-eql-exec-is-add-to-set-equal13157,507458
(defmacro add-to-set (x lst &key (test ''eql))add-to-set13165,507732
(defmacro variablep (x) (list 'atom x))variablep13217,509874
(defmacro nvariablep (x) (list 'consp x))nvariablep13219,509915
(defmacro fquotep (x) (list 'eq ''quote (list 'car x)))fquotep13221,509958
(defun quotep (x)quotep13223,510015
(defconst *t* (quote (quote t)))*t*13228,510109
(defconst *nil* (quote (quote nil)))*nil*13229,510142
(defconst *0* (quote (quote 0)))*0*13230,510179
(defconst *1* (quote (quote 1)))*1*13231,510212
(defconst *-1* (quote (quote -1)))*-1*13232,510245
(defun kwote (x)kwote13234,510281
(defun kwote-lst (lst)kwote-lst13263,511111
(defmacro unquote (x) (list 'cadr x))unquote13278,511566
(defmacro ffn-symb (x) (list 'car x))ffn-symb13280,511605
(defun fn-symb (x)fn-symb13282,511644
(defmacro fargs (x) (list 'cdr x))fargs13289,511773
(defun all-vars1 (term ans)all-vars113293,511828
(defun all-vars1-lst (lst ans)all-vars1-lst13302,512129
(defun all-vars (term)all-vars13316,512564
(defmacro translate-and-test (test-fn form)translate-and-test13361,514910
(defun intersectp-eq-exec (x y)intersectp-eq-exec13429,518421
(defun intersectp-eql-exec (x y)intersectp-eql-exec13438,518752
(defun intersectp-equal (x y)intersectp-equal13447,519084
(defmacro intersectp-eq (x y)intersectp-eq13454,519311
(defthm intersectp-eq-exec-is-intersectp-equalintersectp-eq-exec-is-intersectp-equal13457,519375
(defthm intersectp-eql-exec-is-intersectp-equalintersectp-eql-exec-is-intersectp-equal13461,519491
(defmacro intersectp (x y &key (test ''eql))intersectp13465,519609
(defun make-fmt-bindings (chars forms)make-fmt-bindings13515,521509
(defmacro msg (str &rest args)msg13524,521884
(defun check-vars-not-free-test (vars term)check-vars-not-free-test13654,526758
(defmacro check-vars-not-free (vars form)check-vars-not-free13662,527064
(defun er-progn-fn (lst)er-progn-fn13678,527643
(defmacro er-progn (&rest lst)er-progn13702,528642
(defun er-progn-fn@par (lst)er-progn-fn@par13755,530599
(defmacro er-progn@par (&rest lst)er-progn@par13778,531554
(defun legal-case-clausesp (tl)legal-case-clausesp13792,531821
(defun case-test (x pat)case-test13808,532339
(defun case-list (x l)case-list13813,532496
(defun case-list-check (l)case-list-check13825,532919
(defmacro case (&rest l)case13842,533628
(defun position-ac-eq-exec (item lst acc)position-ac-eq-exec13909,535248
(defun position-ac-eql-exec (item lst acc)position-ac-eql-exec13920,535609
(defun position-equal-ac (item lst acc)position-equal-ac13931,535975
(defmacro position-ac-equal (item lst acc)position-ac-equal13945,536431
(defmacro position-eq-ac (item lst acc)position-eq-ac13949,536564
(defmacro position-ac-eq (item lst acc)position-ac-eq13957,536809
(defthm position-ac-eq-exec-is-position-equal-acposition-ac-eq-exec-is-position-equal-ac13960,536894
(defthm position-ac-eql-exec-is-position-equal-acposition-ac-eql-exec-is-position-equal-ac13964,537032
(defmacro position-ac (item lst acc &key (test ''eql))position-ac13968,537172
(defun position-eq-exec (item lst)position-eq-exec13986,537827
(defun position-eql-exec (item lst)position-eql-exec13992,538052
(defun position-equal (item lst)position-equal14001,538397
(defmacro position-eq (item lst)position-eq14010,538728
(defthm position-eq-exec-is-position-equalposition-eq-exec-is-position-equal14013,538798
(defthm position-eql-exec-is-position-equalposition-eql-exec-is-position-equal14018,538966
(defmacro position (x seq &key (test ''eql))position14023,539103
(defun nonnegative-integer-quotient (i j)nonnegative-integer-quotient14077,541297
(defun true-list-listp (x)true-list-listp14113,542517
(defthm true-list-listp-forward-to-true-listptrue-list-listp-forward-to-true-listp14130,543042
(defun legal-let*-p (bindings ignore-vars ignored-seen top-form)legal-let*-p14135,543182
(defun well-formed-type-decls-p (decls vars)well-formed-type-decls-p14174,545208
(defun symbol-list-listp (x)symbol-list-listp14186,545615
(defun get-type-decls (var type-decls)get-type-decls14192,545791
(defun let*-macro (bindings ignore-vars ignorable-vars type-decls body)let*-macro14203,546303
(defun collect-cdrs-when-car-eq (x alist)collect-cdrs-when-car-eq14246,548695
(defun append-lst (lst)append-lst14255,549048
(defun restrict-alist (keys alist)restrict-alist14260,549203
(defmacro let* (&whole form bindings &rest decl-body)let*14276,549624
(defmacro progn (&rest r)progn14360,553389
(defun floor1 (x)floor114408,555225
(defdoc realreal14418,555384
(defun floor (i j)floor14471,557576
(defun ceiling (i j)ceiling14541,560158
(defun truncate (i j)truncate14600,562105
(defun round (i j)round14663,564219
(defun mod (x y)mod14735,566308
(defun rem (x y)rem14769,567116
(defun evenp (x)evenp14803,567938
(defun oddp (x)oddp14823,568494
(defun zerop (x)zerop14842,568975
(defun plusp (x)plusp14871,569916
(defun minusp (x)minusp14893,570455
(defun min (x y)min14915,570998
(defun max (x y)max14939,571583
(defun abs (x)abs14965,572292
(defun signum (x)signum14990,573033
(defun lognot (i)lognot15027,574239
(defthm standard-char-p-nthstandard-char-p-nth15054,575041
(deflabel proof-of-well-foundednessproof-of-well-foundedness15067,575540
(defun expt (r i)expt15248,582880
(defun logcount (x)logcount15280,583977
(defun nthcdr (n l)nthcdr15307,584650
(defun logbitp (i j)logbitp15342,585599
(defun ash (i c)ash15366,586375
(defthm expt-type-prescription-non-zero-baseexpt-type-prescription-non-zero-base15394,587257
(defthm realp-expt-type-prescriptionrealp-expt-type-prescription15403,587540
(defthm rationalp-expt-type-prescriptionrationalp-expt-type-prescription15408,587666
(deflabel characterscharacters15417,587882
(defaxiom char-code-linearchar-code-linear15485,590646
(defaxiom code-char-typecode-char-type15494,590884
(defaxiom code-char-char-code-is-identitycode-char-char-code-is-identity15498,590975
(defaxiom char-code-code-char-is-identitychar-code-code-char-is-identity15502,591101
(defun char< (x y)char<15509,591315
(defun char> (x y)char>15529,591888
(defun char<= (x y)char<=15549,592467
(defun char>= (x y)char>=15569,593066
(defun string<-l (l1 l2 i)string<-l15588,593654
(defun string< (str1 str2)string<15602,594081
(defun string> (str1 str2)string>15639,595121
(defun string<= (str1 str2)string<=15660,595748
(defun string>= (str1 str2)string>=15686,596613
(defun symbol-< (x y)symbol-<15711,597461
(defthm string<-l-irreflexivestring<-l-irreflexive15737,598410
(defthm string<-irreflexivestring<-irreflexive15740,598468
(defun substitute-ac (new old seq acc)substitute-ac15743,598520
(defun substitute (new old seq)substitute15757,598966
(defun sublis (alist tree)sublis15793,600310
(defun subst (new old tree)subst15823,601350
(defmacro pprogn (&rest lst)pprogn15848,602175
(defmacro progn$ (&rest rst)progn$15911,604130
(defmacro pprogn@par (&rest rst)pprogn@par15937,604841
(defparameter *acl2-unwind-protect-stack* nil)*acl2-unwind-protect-stack*16066,612457
(defmacro push-car (item place ctx)push-car16069,612522
(defmacro acl2-unwind-protect (expl body cleanup1 cleanup2)acl2-unwind-protect16087,613342
(defun-one-output acl2-unwind (n flg)acl2-unwind16193,618249
(defmacro when-logic (str x)when-logic16369,627978
(defmacro in-package (str)in-package16393,628859
(defmacro defpkg (&whole event-form name form &optional doc book-path hidden-p)defpkg16422,629708
(defdoc managing-acl2-packagesmanaging-acl2-packages16544,635544
(deflabel hidden-defpkghidden-defpkg16553,635819
(deflabel hidden-death-packagehidden-death-package16561,635951
(defmacro defun (&whole event-form &rest def)defun16623,638577
(defmacro defun-std (&whole event-form &rest def)defun-std16868,650539
(defmacro defuns (&whole event-form &rest def-lst)defuns16884,650902
(defmacro defuns-std (&whole event-form &rest def-lst)defuns-std16927,652165
(defmacro verify-termination (&rest lst)verify-termination16942,652539
(defmacro verify-termination-boot-strap (&whole event-form &rest lst)verify-termination-boot-strap17106,660607
(defmacro verify-guards (&whole event-form name &key hints otf-flg guard-debugverify-guards17116,660888
(defmacro verify-guards+ (name &rest rest)verify-guards+17440,676004
(defdoc defpundefpun17518,679780
(defmacro defmacro (&whole event-form &rest mdef)defmacro17553,681135
(defmacro defconst (&whole event-form name form &optional doc)defconst17646,685145
(defmacro defthm (&whole event-formdefthm17717,688175
(defmacro defthmd (&whole event-formdefthmd17798,691218
(defmacro defthm-std (&whole event-formdefthm-std17844,692592
(defmacro defaxiom (&whole event-form name termdefaxiom17872,693334
(defmacro deflabel (&whole event-form name &key doc)deflabel17919,695030
(deflabel theoriestheories17960,696555
(defmacro deftheory (&whole event-form name expr &key doc)deftheory18119,705050
(defmacro deftheory-static (name theory)deftheory-static18204,708362
(defmacro defstobj (&whole event-form name &rest args)defstobj18283,711721
(defmacro in-theory (&whole event-form expr &key doc)in-theory18723,733027
(defmacro in-arithmetic-theory (&whole event-form expr &key doc)in-arithmetic-theory18788,735867
(defmacro regenerate-tau-database (&whole event-form &key doc)regenerate-tau-database18847,738352
(defmacro push-untouchable (&whole event-form name fn-p &key doc)push-untouchable18926,742437
(defmacro remove-untouchable (&whole event-form name fn-p &key doc)remove-untouchable18984,744858
(defmacro set-body (&whole event-form fn name-or-rune)set-body19083,749474
(defmacro table (&whole event-form name &rest args)table19124,751086
(defmacro encapsulate (&whole event-form signatures &rest cmd-lst)encapsulate19341,762547
(defdoc redundant-encapsulateredundant-encapsulate19602,775116
(defconst *load-compiled-file-values**load-compiled-file-values*19695,779137
(defmacro include-book (&whole event-form user-book-nameinclude-book19699,779226
(defmacro make-event (&whole event-formmake-event19902,790111
(defdoc make-event-detailsmake-event-details20641,824716
(defdoc using-tables-efficientlyusing-tables-efficiently20865,836610
(defmacro record-expansion (x y)record-expansion20946,839809
(defmacro skip-proofs (x)skip-proofs21149,850424
(defmacro local (x)local21257,855972
(defmacro defchoose (&whole event-form &rest def)defchoose21317,858438
(deflabel conservativity-of-defchooseconservativity-of-defchoose21478,864638
(defmacro defattach (&whole event-form &rest args)defattach21888,884646
(defun attachment-symbol (x)attachment-symbol22405,908426
(defun set-attachment-symbol-form (fn val)set-attachment-symbol-form22412,908603
(defmacro defattach (&rest args)defattach22415,908696
(deflabel worldp) ; reserving this symbol for later useworldp22496,912477
(defun plist-worldp (alist)plist-worldp22498,912534
(defthm plist-worldp-forward-to-assoc-eq-equal-alistpplist-worldp-forward-to-assoc-eq-equal-alistp22533,913992
(defdoc getpropgetprop22538,914148
(defun putprop (symb key value world-alist)putprop22554,914590
(defparameter meter-maid-cnt 0)meter-maid-cnt22618,916865
(defun meter-maid (fn maximum &optional arg1 arg2 cnt)meter-maid22621,916915
(defconst *acl2-property-unbound* :acl2-property-unbound)*acl2-property-unbound*22639,917731
(defun getprop-default (symb key default)getprop-default22641,917790
(defun-one-output sgetprop1 (symb key default world-alist inst-world-alistsgetprop122657,918299
(defun fgetprop (symb key default world-alist)fgetprop22764,922665
(defun sgetprop (symb key default world-name world-alist)sgetprop22822,925250
(defun ordered-symbol-alistp (x)ordered-symbol-alistp22860,926863
(defthm ordered-symbol-alistp-forward-to-symbol-alistpordered-symbol-alistp-forward-to-symbol-alistp22878,927414
(defun add-pair (key value l)add-pair22883,927572
(defun delete-assoc-eq-exec (key alist)delete-assoc-eq-exec22897,927987
(defun delete-assoc-eql-exec (key alist)delete-assoc-eql-exec22905,928310
(defun delete-assoc-equal (key alist)delete-assoc-equal22913,928638
(defmacro delete-assoc-eq (key lst)delete-assoc-eq22919,928863
(defthm delete-assoc-eq-exec-is-delete-assoc-equaldelete-assoc-eq-exec-is-delete-assoc-equal22922,928939
(defthm delete-assoc-eql-exec-is-delete-assoc-equaldelete-assoc-eql-exec-is-delete-assoc-equal22926,929071
(defmacro delete-assoc (key alist &key (test ''eql))delete-assoc22930,929205
(defun getprops1 (alist)getprops122983,931418
(defun getprops (symb world-name world-alist)getprops22998,932039
(defthm equal-char-codeequal-char-code23043,933828
(defun has-propsp1 (alist exceptions known-unbound)has-propsp123057,934229
(defun has-propsp (symb exceptions world-name world-alist known-unbound)has-propsp23078,935176
(defun extend-world (name wrld)extend-world23110,936542
(defun retract-world (name wrld)retract-world23130,937209
(defun global-val (var wrld)global-val23150,937878
(defun function-symbolp (sym wrld)function-symbolp23167,938547
(defun translate-declaration-to-guard/integer (lo var hi)translate-declaration-to-guard/integer23188,939611
(defun weak-satisfies-type-spec-p (x)weak-satisfies-type-spec-p23234,941509
(defun translate-declaration-to-guard1 (x var wrld)translate-declaration-to-guard123248,942020
(defun translate-declaration-to-guard (x var wrld)translate-declaration-to-guard23434,949556
(defun translate-declaration-to-guard-lst (l var wrld)translate-declaration-to-guard-lst23507,952982
(deflabel declaredeclare23533,953860
(deflabel type-spectype-spec23595,956277
(defun the-check (guard x y)the-check23672,959633
(defun the-fn (x y)the-fn23682,960029
(defmacro the (x y)the23732,962447
(defconst *maximum-positive-32-bit-integer**maximum-positive-32-bit-integer*23859,968623
(defconst *our-array-total-size-limit**our-array-total-size-limit*23863,968705
(defun-one-output chk-make-array$ (dimensions form)chk-make-array$23875,969137
(defmacro make-array$ (&whole form dimensions &rest args)make-array$23908,970609
(defparameter *acl2-array-cache**acl2-array-cache*24004,975423
(defmacro set-acl2-array-property (name prop)set-acl2-array-property24012,975691
(defmacro get-acl2-array-property (name)get-acl2-array-property24061,977492
(defun bounded-integer-alistp (l n)bounded-integer-alistp24089,978482
(defthm bounded-integer-alistp-forward-to-eqlable-alistpbounded-integer-alistp-forward-to-eqlable-alistp24105,979055
(defun keyword-value-listp (l)keyword-value-listp24110,979219
(defthm keyword-value-listp-forward-to-true-listpkeyword-value-listp-forward-to-true-listp24128,979762
(defun assoc-keyword (key l)assoc-keyword24133,979910
(defthm keyword-value-listp-assoc-keywordkeyword-value-listp-assoc-keyword24155,980633
(defthm consp-assoc-equalconsp-assoc-equal24161,980863
(defmacro f-get-global (x st)f-get-global24181,981738
(defun our-import (syms pkg)our-import24219,982850
(defvar *defpkg-virgins* nil)*defpkg-virgins*24238,983868
(defun check-proposed-imports (name package-entry proposed-imports)check-proposed-imports24240,983899
(defun-one-output defpkg-raw1 (name imports book-path event-form)defpkg-raw124299,986872
(defun package-has-no-imports (name)package-has-no-imports24393,990887
(defmacro maybe-make-package (name)maybe-make-package24401,991128
(defmacro maybe-introduce-empty-pkg-1 (name)maybe-introduce-empty-pkg-124485,994181
(defmacro maybe-introduce-empty-pkg-2 (name)maybe-introduce-empty-pkg-224530,996163
(defmacro defpkg-raw (name imports book-path event-form)defpkg-raw24538,996484
(defun-one-output slow-array-warning (fn nm)slow-array-warning24568,997743
(deflabel arraysarrays24585,998434
(deflabel arrays-examplearrays-example25000,1020882
(deflabel slow-array-warningslow-array-warning25080,1023727
(defun array1p (name l)array1p25184,1029157
(defthm array1p-forwardarray1p-forward25235,1031469
(defthm array1p-lineararray1p-linear25255,1032630
(defun bounded-integer-alistp2 (l i j)bounded-integer-alistp225264,1033134
(defun assoc2 (i j l)assoc225283,1033964
(defun array2p (name l)array2p25295,1034269
(defthm array2p-forwardarray2p-forward25338,1035999
(defthm array2p-lineararray2p-linear25363,1037564
(defun header (name l)header25376,1038295
(defun dimensions (name l)dimensions25408,1039285
(defun maximum-length (name l)maximum-length25435,1040375
(defun default (name l)default25459,1041268
(defun aref1 (name l n)aref125507,1043537
(defun compress11 (name l i n default)compress1125558,1045317
(defconstant *invisible-array-mark* 'acl2_invisible::|An Invisible Array Mark|)*invisible-array-mark*25573,1045908
(defun array-order (header)array-order25575,1045989
(defun compress1 (name l)compress125588,1046382
(defthm array1p-consarray1p-cons25855,1059244
(defun aset1 (name l n val)aset125865,1059602
(defun aref2 (name l i j)aref225989,1065698
(defun compress211 (name l i x j default)compress21126036,1067392
(defun compress21 (name l n i j default)compress2126052,1068030
(defun compress2 (name l)compress226065,1068516
(defthm array2p-consarray2p-cons26243,1076477
(defun aset2 (name l i j val)aset226254,1076855
(defun flush-compress (name)flush-compress26367,1081729
(defparameter *return-values**return-values*26528,1088064
(defmacro declare-return-values ()declare-return-values26535,1088253
(defun declare-return-values1 ()declare-return-values126538,1088331
(defun in-akcl-with-mv-set-and-ref ()in-akcl-with-mv-set-and-ref26549,1088553
(defconstant *akcl-mv-ref-and-set-inclusive-upper-bound* 9)*akcl-mv-ref-and-set-inclusive-upper-bound*26552,1088628
(defmacro special-location (i)special-location26554,1088689
(defmacro set-mv (i v)set-mv26564,1089098
(defmacro mv-ref (i)mv-ref26577,1089564
(defun mv-refs-fn (i)mv-refs-fn26589,1089996
(defmacro mv-refs (i)mv-refs26597,1090130
(defun cdrn (x i)cdrn26614,1090553
(defun mv-nth (n l)mv-nth26620,1090719
(defun make-mv-nths (args call i)make-mv-nths26672,1092740
(defun mv-bindings (lst)mv-bindings26680,1093052
(defun mv-set-mvs (bindings i)mv-set-mvs26690,1093376
(defmacro mv (&rest l)mv26695,1093541
(defmacro mv? (&rest l)mv?26843,1099096
(defmacro mv-let (&rest rst)mv-let26914,1101460
(defmacro mv?-let (vars form &rest rst)mv?-let27068,1108086
(defun mv-list (input-arity x)mv-list27124,1109721
(defmacro mv-list (input-arity x)mv-list27169,1111503
(defmacro mv-list (input-arity x)mv-list27174,1111653
(deflabel statestate27177,1111730
(defdoc programming-with-stateprogramming-with-state27352,1120894
(defdoc error-tripleserror-triples27887,1144010
(defun update-nth (key val l)update-nth27915,1145195
(defun update-nth-array (j key val l)update-nth-array27958,1146515
(defmacro maximum-positive-32-bit-integer ()maximum-positive-32-bit-integer27969,1146945
(defmacro maximum-positive-32-bit-integer-minus-1 ()maximum-positive-32-bit-integer-minus-127972,1147028
(defun 32-bit-integerp (x)32-bit-integerp27975,1147130
(defthm 32-bit-integerp-forward-to-integerp32-bit-integerp-forward-to-integerp27981,1147313
(defun acl2-number-listp (l)acl2-number-listp27986,1147449
(defthm acl2-number-listp-forward-to-true-listpacl2-number-listp-forward-to-true-listp28003,1147873
(defun rational-listp (l)rational-listp28008,1148017
(defthm rational-listp-forward-to-acl2-number-listprational-listp-forward-to-acl2-number-listp28025,1148447
(defun real-listp (l)real-listp28033,1148680
(defdoc real-listpreal-listp28040,1148844
(defthm real-listp-forward-to-acl2-number-listpreal-listp-forward-to-acl2-number-listp28052,1149193
(defun integer-listp (l)integer-listp28057,1149337
(defthm integer-listp-forward-to-rational-listpinteger-listp-forward-to-rational-listp28074,1149747
(defun nat-listp (l)nat-listp28079,1149891
(defthm nat-listp-forward-to-integer-listpnat-listp-forward-to-integer-listp28096,1150300
(defthm rational-listp-forward-to-real-listprational-listp-forward-to-real-listp28104,1150527
(defun 32-bit-integer-listp (l)32-bit-integer-listp28109,1150665
(defthm 32-bit-integer-listp-forward-to-integer-listp32-bit-integer-listp-forward-to-integer-listp28115,1150853
(defun open-input-channels (st)open-input-channels28124,1151204
(defun update-open-input-channels (x st)update-open-input-channels28128,1151294
(defun open-output-channels (st)open-output-channels28132,1151402
(defun update-open-output-channels (x st)update-open-output-channels28136,1151493
(defun global-table (st)global-table28140,1151602
(defun update-global-table (x st)update-global-table28144,1151685
(defun t-stack (st)t-stack28148,1151786
(defun update-t-stack (x st)update-t-stack28152,1151864
(defun 32-bit-integer-stack (st)32-bit-integer-stack28156,1151960
(defun update-32-bit-integer-stack (x st)update-32-bit-integer-stack28160,1152051
(defun big-clock-entry (st)big-clock-entry28164,1152160
(defun update-big-clock-entry (x st)update-big-clock-entry28168,1152246
(defun idates (st)idates28172,1152350
(defun update-idates (x st)update-idates28176,1152427
(defun acl2-oracle (st)acl2-oracle28180,1152522
(defun update-acl2-oracle (x st)update-acl2-oracle28184,1152604
(defun file-clock (st)file-clock28188,1152704
(defun update-file-clock (x st)update-file-clock28192,1152785
(defun readable-files (st)readable-files28196,1152884
(defun written-files (st)written-files28200,1152969
(defun update-written-files (x st)update-written-files28204,1153054
(defun read-files (st)read-files28208,1153157
(defun update-read-files (x st)update-read-files28212,1153239
(defun writeable-files (st)writeable-files28216,1153339
(defun list-all-package-names-lst (st)list-all-package-names-lst28220,1153426
(defun update-list-all-package-names-lst (x st)update-list-all-package-names-lst28224,1153524
(defun user-stobj-alist1 (st)user-stobj-alist128232,1153852
(defun update-user-stobj-alist1 (x st)update-user-stobj-alist128236,1153941
(defconst *initial-raw-arity-alist**initial-raw-arity-alist*28241,1154068
(defconst *initial-checkpoint-processors**initial-checkpoint-processors*28267,1154795
(defconst *primitive-program-fns-with-raw-code**primitive-program-fns-with-raw-code*28286,1155533
(defconst *primitive-logic-fns-with-raw-code**primitive-logic-fns-with-raw-code*28399,1159724
(defconst *primitive-macros-with-raw-code**primitive-macros-with-raw-code*28559,1166091
(defmacro with-live-state (form)with-live-state28652,1169692
(defun init-iprint-ar (hard-bound enabledp)init-iprint-ar28761,1173795
(defconst *iprint-soft-bound-default* 1000)*iprint-soft-bound-default*28793,1175188
(defconst *iprint-hard-bound-default* 10000)*iprint-hard-bound-default*28794,1175232
(defdoc parallelismparallelism28796,1175278
(defdoc parallel-programmingparallel-programming28833,1177233
(defdoc parallel-proofparallel-proof28871,1179128
(defun default-total-parallelism-work-limit ()default-total-parallelism-work-limit28884,1179556
(defconst *fmt-soft-right-margin-default* 65)*fmt-soft-right-margin-default*28962,1183525
(defconst *fmt-hard-right-margin-default* 77)*fmt-hard-right-margin-default*28963,1183571
(defconst *initial-global-table**initial-global-table*28965,1183618
(defun all-boundp (alist1 alist2)all-boundp29257,1196385
(defun known-package-alistp (x)known-package-alistp29265,1196656
(defthm known-package-alistp-forward-to-true-list-listp-and-alistpknown-package-alistp-forward-to-true-list-listp-and-alistp29276,1197037
(defun timer-alistp (x)timer-alistp29282,1197241
(defthm timer-alistp-forward-to-true-list-listp-and-symbol-alistptimer-alistp-forward-to-true-list-listp-and-symbol-alistp29294,1197553
(defun typed-io-listp (l typ)typed-io-listp29300,1197755
(defthm typed-io-listp-forward-to-true-listptyped-io-listp-forward-to-true-listp29312,1198206
(defconst *file-types* '(:character :byte :object))*file-types*29317,1198348
(defun open-channel1 (l)open-channel129319,1198401
(defthm open-channel1-forward-to-true-listp-and-conspopen-channel1-forward-to-true-listp-and-consp29333,1198816
(defun open-channel-listp (l)open-channel-listp29339,1198994
(defun open-channels-p (x)open-channels-p29352,1199351
(defthm open-channels-p-forwardopen-channels-p-forward29357,1199473
(defun file-clock-p (x)file-clock-p29363,1199652
(defthm file-clock-p-forward-to-integerpfile-clock-p-forward-to-integerp29367,1199718
(defun readable-file (x)readable-file29372,1199844
(defthm readable-file-forward-to-true-listp-and-conspreadable-file-forward-to-true-listp-and-consp29384,1200206
(defun readable-files-listp (x)readable-files-listp29390,1200384
(defthm readable-files-listp-forward-to-true-list-listp-and-alistpreadable-files-listp-forward-to-true-list-listp-and-alistp29396,1200570
(defun readable-files-p (x)readable-files-p29402,1200774
(defthm readable-files-p-forward-to-readable-files-listpreadable-files-p-forward-to-readable-files-listp29406,1200860
(defun written-file (x)written-file29411,1201022
(defthm written-file-forward-to-true-listp-and-conspwritten-file-forward-to-true-listp-and-consp29424,1201421
(defun written-file-listp (x)written-file-listp29430,1201597
(defthm written-file-listp-forward-to-true-list-listp-and-alistpwritten-file-listp-forward-to-true-list-listp-and-alistp29436,1201778
(defun written-files-p (x)written-files-p29442,1201978
(defthm written-files-p-forward-to-written-file-listpwritten-files-p-forward-to-written-file-listp29446,1202061
(defun read-file-listp1 (x)read-file-listp129451,1202217
(defthm read-file-listp1-forward-to-true-listp-and-conspread-file-listp1-forward-to-true-listp-and-consp29460,1202447
(defun read-file-listp (x)read-file-listp29466,1202631
(defthm read-file-listp-forward-to-true-list-listpread-file-listp-forward-to-true-list-listp29472,1202810
(defun read-files-p (x)read-files-p29477,1202960
(defthm read-files-p-forward-to-read-file-listpread-files-p-forward-to-read-file-listp29481,1203037
(defun writable-file-listp1 (x)writable-file-listp129486,1203181
(defthm writable-file-listp1-forward-to-true-listp-and-conspwritable-file-listp1-forward-to-true-listp-and-consp29494,1203386
(defun writable-file-listp (x)writable-file-listp29500,1203578
(defthm writable-file-listp-forward-to-true-list-listpwritable-file-listp-forward-to-true-list-listp29506,1203769
(defun writeable-files-p (x)writeable-files-p29511,1203927
(defthm writeable-files-p-forward-to-writable-file-listpwriteable-files-p-forward-to-writable-file-listp29515,1204013
(defun state-p1 (x)state-p129520,1204175
(defthm state-p1-forwardstate-p1-forward29555,1205605
(defun state-p (state-state)state-p29598,1207501
(defthm state-p-implies-and-forward-to-state-p1state-p-implies-and-forward-to-state-p129608,1207758
(defmacro build-statebuild-state29701,1213075
(defconst *default-state**default-state*29725,1214008
(defun build-state1 (open-input-channelsbuild-state129730,1214142
(defun coerce-state-to-object (x)coerce-state-to-object29758,1215402
(defun coerce-object-to-state (x)coerce-object-to-state29762,1215471
(defun-one-output strip-numeric-postfix (sym)strip-numeric-postfix29772,1215644
(defun global-table-cars1 (state-state)global-table-cars129780,1215884
(defun global-table-cars (state-state)global-table-cars29805,1217028
(defun boundp-global1 (x state-state)boundp-global129812,1217232
(defun boundp-global (x state-state)boundp-global29821,1217558
(defmacro f-boundp-global (x st)f-boundp-global29829,1217806
(defun makunbound-global (x state-state)makunbound-global29845,1218338
(defun get-global (x state-state)get-global29874,1219397
(defun put-global (key value state-state)put-global29886,1219812
(defmacro f-put-global (key value st)f-put-global29907,1220632
(defmacro f-put-global@par (key value st)f-put-global@par29970,1223231
(defconst *initial-ld-special-bindings**initial-ld-special-bindings*29988,1223833
(defun always-boundp-global (x)always-boundp-global30012,1224688
(defun state-global-let*-bindings-p (lst)state-global-let*-bindings-p30019,1224885
(defun state-global-let*-get-globals (bindings)state-global-let*-get-globals30036,1225516
(defun state-global-let*-put-globals (bindings)state-global-let*-put-globals30065,1227066
(defun state-global-let*-cleanup (bindings index)state-global-let*-cleanup30098,1228793
(defparameter *possible-parallelism-hazards**possible-parallelism-hazards*30149,1231682
(defmacro with-parallelism-hazard-warnings (body)with-parallelism-hazard-warnings30190,1233045
(defmacro warn-about-parallelism-hazard (call body)warn-about-parallelism-hazard30200,1233295
(defmacro with-ensured-parallelism-finishing (form)with-ensured-parallelism-finishing30257,1236118
(defmacro state-global-let* (bindings body)state-global-let*30270,1236516
(defmacro state-free-global-let* (bindings body)state-free-global-let*30390,1241893
(defun integer-range-p (lower upper x)integer-range-p30433,1243916
(defun signed-byte-p (bits x)signed-byte-p30459,1244951
(defun unsigned-byte-p (bits x)unsigned-byte-p30484,1245789
(defthm integer-range-p-forwardinteger-range-p-forward30512,1246682
(defthm signed-byte-p-forward-to-integerpsigned-byte-p-forward-to-integerp30520,1246932
(defthm unsigned-byte-p-forward-to-nonnegative-integerpunsigned-byte-p-forward-to-nonnegative-integerp30525,1247066
(defmacro the-fixnum (n)the-fixnum30533,1247329
(defun-one-output zpf (x)zpf30537,1247407
(defun zpf (x)zpf30541,1247516
(defmacro logand (&rest args)logand30790,1255710
(defmacro logeqv (&rest args)logeqv30813,1256442
(defmacro logior (&rest args)logior30836,1257186
(defmacro logxor (&rest args)logxor30859,1257930
(defun integer-length (i)integer-length30882,1258674
(defun binary-logand (i j)binary-logand30911,1259654
(defun lognand (i j)lognand30925,1260121
(defun binary-logior (i j)binary-logior30944,1260697
(defun logorc1 (i j)logorc130950,1260874
(defun logorc2 (i j)logorc230971,1261558
(defun logandc1 (i j)logandc130992,1262243
(defun logandc2 (i j)logandc231013,1262917
(defun binary-logeqv (i j)binary-logeqv31033,1263575
(defun binary-logxor (i j)binary-logxor31039,1263742
(defun lognor (i j)lognor31045,1263901
(defun logtest (x y)logtest31066,1264517
(defconst *BOOLE-1*      0)*BOOLE-1*31090,1265257
(defconst *BOOLE-2*      1)*BOOLE-2*31091,1265285
(defconst *BOOLE-AND*    2)*BOOLE-AND*31092,1265313
(defconst *BOOLE-ANDC1*  3)*BOOLE-ANDC1*31093,1265341
(defconst *BOOLE-ANDC2*  4)*BOOLE-ANDC2*31094,1265369
(defconst *BOOLE-C1*     5)*BOOLE-C1*31095,1265397
(defconst *BOOLE-C2*     6)*BOOLE-C2*31096,1265425
(defconst *BOOLE-CLR*    7)*BOOLE-CLR*31097,1265453
(defconst *BOOLE-EQV*    8)*BOOLE-EQV*31098,1265481
(defconst *BOOLE-IOR*    9)*BOOLE-IOR*31099,1265509
(defconst *BOOLE-NAND*  10)*BOOLE-NAND*31100,1265537
(defconst *BOOLE-NOR*   11)*BOOLE-NOR*31101,1265565
(defconst *BOOLE-ORC1*  12)*BOOLE-ORC1*31102,1265593
(defconst *BOOLE-ORC2*  13)*BOOLE-ORC2*31103,1265621
(defconst *BOOLE-SET*   14)*BOOLE-SET*31104,1265649
(defconst *BOOLE-XOR*   15)*BOOLE-XOR*31105,1265677
(defun boole$ (op i1 i2)boole$31107,1265706
(deflabel ioio31177,1268288
(defdoc output-to-fileoutput-to-file31420,1279238
(defdoc *standard-co**standard-co*31475,1281461
(defdoc *standard-oi**standard-oi*31514,1283534
(defdoc *standard-ci**standard-ci*31528,1284114
(defdoc print-controlprint-control31544,1284722
(defdoc character-encodingcharacter-encoding31643,1290006
(defun set-forms-from-bindings (bindings)set-forms-from-bindings31690,1292193
(defconst *print-control-defaults**print-control-defaults*31702,1292653
(defun alist-difference-eq (alist1 alist2)alist-difference-eq31727,1293947
(defmacro with-print-defaults (bindings form)with-print-defaults31743,1294491
(defmacro reset-print-control ()reset-print-control31752,1294962
(defun digit-to-char (n)digit-to-char31756,1295073
(defun print-base-p (print-base)print-base-p31797,1296087
(defun explode-nonnegative-integer (n print-base ans)explode-nonnegative-integer31804,1296240
(defthm true-listp-explode-nonnegative-integertrue-listp-explode-nonnegative-integer31852,1297860
(defun explode-atom (x print-base)explode-atom31881,1298784
(defun explode-atom+ (x print-base print-radix)explode-atom+31925,1300435
(defthm true-list-listp-forward-to-true-listp-assoc-equaltrue-list-listp-forward-to-true-listp-assoc-equal31961,1301902
(defthm true-listp-cadr-assoc-eq-for-open-channels-ptrue-listp-cadr-assoc-eq-for-open-channels-p31980,1302870
(defun open-input-channel-p1 (channel typ state-state)open-input-channel-p131995,1303384
(defun open-output-channel-p1 (channel typ state-state)open-output-channel-p132010,1304047
(defun open-input-channel-p (channel typ state-state)open-input-channel-p32024,1304689
(defun open-output-channel-p (channel typ state-state)open-output-channel-p32030,1304958
(defun open-output-channel-any-p1 (channel state-state)open-output-channel-any-p132036,1305229
(defun open-output-channel-any-p (channel state-state)open-output-channel-any-p32043,1305570
(defun open-input-channel-any-p1 (channel state-state)open-input-channel-any-p132048,1305782
(defun open-input-channel-any-p (channel state-state)open-input-channel-any-p32055,1306119
(defmacro print-case ()print-case32060,1306329
(defmacro acl2-print-case (&optional (st 'state))acl2-print-case32069,1306594
(defun set-print-case (case state)set-print-case32072,1306666
(defmacro set-acl2-print-case (case)set-acl2-print-case32112,1308652
(defmacro print-base (&optional (st 'state))print-base32118,1308849
(defmacro acl2-print-base (&optional (st 'state))acl2-print-base32121,1308930
(defmacro print-radix (&optional (st 'state))print-radix32124,1309002
(defmacro acl2-print-radix (&optional (st 'state))acl2-print-radix32127,1309085
(defun check-print-base (print-base ctx)check-print-base32130,1309159
(defun set-print-base (base state)set-print-base32187,1312001
(defmacro set-acl2-print-base (base)set-acl2-print-base32227,1313306
(defun set-print-circle (x state)set-print-circle32233,1313503
(defun set-print-escape (x state)set-print-escape32237,1313621
(defun set-print-pretty (x state)set-print-pretty32241,1313739
(defun set-print-radix (x state)set-print-radix32245,1313857
(defun set-print-readably (x state)set-print-readably32287,1315054
(defun check-null-or-natp (n fn)check-null-or-natp32291,1315176
(defun set-print-length (n state)set-print-length32302,1315524
(defun set-print-level (n state)set-print-level32308,1315761
(defun set-print-lines (n state)set-print-lines32314,1315995
(defun set-print-right-margin (n state)set-print-right-margin32320,1316229
(defmacro get-input-stream-from-channel (channel)get-input-stream-from-channel32327,1316501
(defmacro get-output-stream-from-channel (channel)get-output-stream-from-channel32334,1316691
(defmacro with-print-controls (default bindings &rest body)with-print-controls32341,1316883
(defun princ$ (x channel state-state)princ$32405,1320075
(defun write-byte$ (x channel state-state)write-byte$32574,1327171
(defvar *print-circle-stream* nil)*print-circle-stream*32603,1328339
(defmacro er (severity context str &rest str-args)er32605,1328375
(defmacro er@par (severity context str &rest str-args)er@par32721,1334037
(defun get-serialize-character (state)get-serialize-character32744,1334962
(defun w (state)w32749,1335169
(defun hons-enabledp (state)hons-enabledp32761,1335696
(defun set-serialize-character (c state)set-serialize-character32766,1335859
(defun print-object$-ser (x serialize-character channel state-state)print-object$-ser32793,1337045
(defthm all-boundp-preserves-assoc-equalall-boundp-preserves-assoc-equal32847,1339325
(defun print-object$ (x channel state)print-object$32864,1339894
(defparameter *file-clock* 1)*file-clock*32900,1341600
(defun make-input-channel (file-name clock)make-input-channel32903,1341644
(defun make-output-channel (file-name clock)make-output-channel32917,1342154
(defun-one-output setup-standard-io ()setup-standard-io32939,1343168
(defun-one-output lisp-book-syntaxp1 (s stream)lisp-book-syntaxp132979,1344660
(defun-one-output lisp-book-syntaxp (file)lisp-book-syntaxp33060,1347783
(defparameter *parser* nil)*parser*33085,1348919
(defun-one-output parse-infix-file (infile outfile)parse-infix-file33098,1349389
(defun open-input-channel (file-name typ state-state)open-input-channel33128,1350631
(defthm nth-update-nthnth-update-nth33243,1355801
(defthm true-listp-update-nthtrue-listp-update-nth33250,1355987
(defthm nth-update-nth-arraynth-update-nth-array33263,1356337
(defun close-input-channel (channel state-state)close-input-channel33269,1356518
(defun open-output-channel (file-name typ state-state)open-output-channel33314,1358412
(defun open-output-channel! (file-name typ state)open-output-channel!33414,1363507
(defmacro assert$ (test form)assert$33545,1368246
(defun fmt-to-comment-window (str alist col evisc-tuple)fmt-to-comment-window33569,1369050
(defun fmt-to-comment-window! (str alist col evisc-tuple)fmt-to-comment-window!33620,1371146
(defun pairlis2 (x y)pairlis233634,1371508
(defmacro cw (str &rest args)cw33642,1371792
(defmacro cw! (str &rest args)cw!33763,1376284
(defun subseq-list (lst start end)subseq-list33782,1376935
(defun subseq (seq start end)subseq33793,1377302
(defun lock-symbol-name-p (lock-symbol)lock-symbol-name-p33833,1379069
(defun assign-lock (key)assign-lock33842,1379361
(defmacro with-lock (bound-symbol &rest forms)with-lock33863,1380039
(defmacro deflock (lock-symbol)deflock33874,1380438
(defun get-output-stream-string$-fn (channel state-state)get-output-stream-string$-fn33918,1382188
(defmacro get-output-stream-string$ (channel state-stateget-output-stream-string$33964,1384200
(defun close-output-channel (channel state-state)close-output-channel33984,1385128
(defun maybe-finish-output$ (channel state)maybe-finish-output$34090,1389943
(defmacro legal-acl2-character-p (x)legal-acl2-character-p34110,1390653
(defun read-char$ (channel state-state)read-char$34126,1391201
(defun peek-char$ (channel state-state)peek-char$34161,1392676
(defun read-byte$ (channel state-state)read-byte$34187,1393726
(defun-one-output parse-infix-from-terminal (eof)parse-infix-from-terminal34216,1394875
(defparameter *acl2-read-suppress* nil)*acl2-read-suppress*34241,1395930
(defun read-object (channel state-state)read-object34243,1395971
(defun read-object-suppress (channel state)read-object-suppress34339,1400278
(defconst *suspiciously-first-numeric-chars**suspiciously-first-numeric-chars*34356,1401036
(defconst *suspiciously-first-hex-chars**suspiciously-first-hex-chars*34363,1401236
(defconst *base-10-chars**base-10-chars*34373,1401488
(defconst *hex-chars**hex-chars*34380,1401630
(defconst *letter-chars**letter-chars*34389,1401820
(defconst *slashable-chars**slashable-chars*34399,1402140
(defun some-slashable (l)some-slashable34407,1402425
(defun prin1-with-slashes1 (l slash-char channel state)prin1-with-slashes134415,1402630
(defun prin1-with-slashes (s slash-char channel state)prin1-with-slashes34434,1403369
(defmacro suspiciously-first-numeric-chars (print-base)suspiciously-first-numeric-chars34460,1404456
(defmacro numeric-chars (print-base)numeric-chars34465,1404621
(defun may-need-slashes1 (lst flg potnum-chars)may-need-slashes134470,1404729
(defmacro potential-numberp (s0 n0 print-base)potential-numberp34494,1405761
(defun may-need-slashes-fn (x print-base)may-need-slashes-fn34556,1408187
(defmacro may-need-slashes (x &optional (print-base '10))may-need-slashes34805,1419128
(defun needs-slashes (x state)needs-slashes34814,1419522
(defparameter *t-stack* (make-array$ 5))*t-stack*34830,1420050
(defparameter *t-stack-length* 0)*t-stack-length*34832,1420092
(defun t-stack-length1 (state-state)t-stack-length134837,1420131
(defun t-stack-length (state-state)t-stack-length34848,1420466
(defun make-list-ac (n val ac)make-list-ac34855,1420664
(defmacro make-list (size &key initial-element)make-list34862,1420872
(defun extend-t-stack (n val state-state)extend-t-stack34879,1421504
(defconst *directory-separator**directory-separator*34954,1424170
(defconst *directory-separator-string**directory-separator-string*34957,1424210
(defmacro os-er (os fnname)os-er34960,1424284
(defun os (wrld)os34968,1424552
(defun mswindows-drive1 (filename)mswindows-drive134978,1424790
(defun mswindows-drive (filename state)mswindows-drive35003,1425995
(defun pathname-os-to-unix (str os state)pathname-os-to-unix35018,1426617
(defun ccl-at-least-1-3-p ()ccl-at-least-1-3-p35059,1428127
(defun pathname-unix-to-os (str state)pathname-unix-to-os35066,1428438
(defun shrink-t-stack (n state-state)shrink-t-stack35120,1430827
(defun aref-t-stack (i state-state)aref-t-stack35145,1431684
(defun aset-t-stack (i val state-state)aset-t-stack35160,1432198
(defparameter *32-bit-integer-stack**32-bit-integer-stack*35188,1432989
(defparameter *32-bit-integer-stack-length* 0)*32-bit-integer-stack-length*35191,1433078
(defun 32-bit-integer-stack-length1 (state-state)32-bit-integer-stack-length135195,1433129
(defun 32-bit-integer-stack-length (state-state)32-bit-integer-stack-length35203,1433438
(defun extend-32-bit-integer-stack (n val state-state)extend-32-bit-integer-stack35210,1433662
(defun shrink-32-bit-integer-stack (n state-state)shrink-32-bit-integer-stack35258,1435980
(defun aref-32-bit-integer-stack (i state-state)aref-32-bit-integer-stack35289,1437110
(defun aset-32-bit-integer-stack (i val state-state)aset-32-bit-integer-stack35312,1437880
(defmacro f-big-clock-negative-p (st)f-big-clock-negative-p35341,1438909
(defmacro f-decrement-big-clock (st)f-decrement-big-clock35350,1439147
(defun big-clock-negative-p (state-state)big-clock-negative-p35369,1439731
(defun decrement-big-clock (state-state)decrement-big-clock35389,1440613
(defun list-all-package-names (state-state)list-all-package-names35414,1441567
(defun user-stobj-alist (state-state)user-stobj-alist35430,1442167
(defun update-user-stobj-alist (x state-state)update-user-stobj-alist35440,1442487
(defun power-eval (l b)power-eval35452,1442921
(defun-one-output idate ()idate35460,1443131
(defun read-idate (state-state)read-idate35472,1443443
(defun get-internal-time ()get-internal-time35492,1444117
(defdoc get-internal-timeget-internal-time35497,1444276
(defun read-run-time (state-state)read-run-time35547,1446435
(defparameter *next-acl2-oracle-value* nil)*next-acl2-oracle-value*35588,1448015
(defun read-acl2-oracle (state-state)read-acl2-oracle35590,1448060
(defun read-acl2-oracle@par (state-state)read-acl2-oracle@par35611,1448739
(defun read-acl2-oracle@par (state-state)read-acl2-oracle@par35636,1449768
(defun getenv$ (str state)getenv$35657,1450757
(defun setenv$ (str val)setenv$35686,1451783
(defun random$ (limit state)random$35742,1453908
(defthm natp-random$natp-random$35781,1455366
(defthm random$-linearrandom$-linear35785,1455457
(defvar *last-sys-call-status* 0)*last-sys-call-status*35802,1455907
(defun sys-call (command-string args)sys-call35804,1455942
(defun sys-call-status (state)sys-call-status35890,1459304
(defun read-file-by-lines (file &optional delete-after-reading)read-file-by-lines35918,1460364
(defun system-call+ (string arguments)system-call+35941,1461118
(defthm update-acl2-oracle-preserves-state-p1update-acl2-oracle-preserves-state-p136101,1467765
(defun sys-call+ (command-string args state)sys-call+36109,1468021
(defthm read-run-time-preserves-state-p1read-run-time-preserves-state-p136257,1474774
(defthm read-acl2-oracle-preserves-state-p1read-acl2-oracle-preserves-state-p136265,1475063
(defthm nth-0-read-run-time-type-prescriptionnth-0-read-run-time-type-prescription36281,1475546
(defun main-timer (state)main-timer36299,1476113
(defun put-assoc-eq-exec (name val alist)put-assoc-eq-exec36312,1476616
(defun put-assoc-eql-exec (name val alist)put-assoc-eql-exec36324,1477076
(defun put-assoc-equal (name val alist)put-assoc-equal36336,1477541
(defmacro put-assoc-eq (name val alist)put-assoc-eq36342,1477813
(defmacro put-assoc-eql (name val alist)put-assoc-eql36347,1477985
(defthm put-assoc-eq-exec-is-put-assoc-equalput-assoc-eq-exec-is-put-assoc-equal36350,1478072
(defthm put-assoc-eql-exec-is-put-assoc-equalput-assoc-eql-exec-is-put-assoc-equal36354,1478206
(defmacro put-assoc (name val alist &key (test ''eql))put-assoc36358,1478342
(defun set-timer (name val state)set-timer36425,1481004
(defun get-timer (name state)get-timer36434,1481288
(defun push-timer (name val state)push-timer36445,1481665
(defthm rationalp-+rationalp-+36454,1482049
(defthm rationalp-*rationalp-*36550,1486315
(defthm rationalp-unary--rationalp-unary--36555,1486430
(defthm rationalp-unary-/rationalp-unary-/36559,1486513
(defthm realp-+realp-+36568,1486849
(defthm realp-*realp-*36574,1486973
(defthm realp-unary--realp-unary--36580,1487097
(defthm realp-unary-/realp-unary-/36585,1487193
(defthm rationalp-implies-acl2-numberprationalp-implies-acl2-numberp36591,1487339
(defun pop-timer (name flg state)pop-timer36594,1487423
(defun add-timers (name1 name2 state)add-timers36612,1488048
(defthm nth-0-consnth-0-cons36626,1488611
(defthm nth-add1nth-add136636,1488813
(defthm main-timer-type-prescriptionmain-timer-type-prescription36643,1489013
(defthm ordered-symbol-alistp-add-pair-forwardordered-symbol-alistp-add-pair-forward36649,1489208
(defthm assoc-add-pairassoc-add-pair36658,1489477
(defthm add-pair-preserves-all-boundpadd-pair-preserves-all-boundp36666,1489757
(defthm state-p1-update-main-timerstate-p1-update-main-timer36673,1490016
(defun increment-timer (name state)increment-timer36704,1491407
(defun print-rational-as-decimal (x channel state)print-rational-as-decimal36727,1492402
(defun print-timer (name channel state)print-timer36748,1493172
(defun known-package-alist (state)known-package-alist36756,1493515
(defun prin1$ (x channel state)prin1$36772,1493921
(defun current-package (state)current-package36953,1502711
(defthm state-p1-update-nth-2-worldstate-p1-update-nth-2-world37007,1505558
(defconst *initial-untouchable-fns**initial-untouchable-fns*37045,1506917
(defconst *initial-untouchable-vars**initial-untouchable-vars*37127,1509406
(defun ld-skip-proofsp (state)ld-skip-proofsp37285,1513923
(defun-one-output bad-lisp-objectp (x)bad-lisp-objectp37396,1519720
(defun-one-output chk-bad-lisp-object (x)chk-bad-lisp-object37630,1531590
(defmacro assign (x y)assign37672,1532824
(defmacro @ (x)@37712,1534350
(defun make-var-lst1 (root sym n acc)make-var-lst137746,1535630
(defun make-var-lst (sym n)make-var-lst37773,1536536
(defun union-eq-exec (l1 l2)union-eq-exec37781,1536766
(defun union-eql-exec (l1 l2)union-eql-exec37791,1537148
(defun union-equal (l1 l2)union-equal37801,1537532
(defmacro union-eq (&rest lst)union-eq37807,1537767
(defthm union-eq-exec-is-union-equalunion-eq-exec-is-union-equal37810,1537828
(defthm union-eql-exec-is-union-equalunion-eql-exec-is-union-equal37814,1537928
(defun parse-args-and-test (x tests default ctx form name)parse-args-and-test37818,1538030
(defmacro union$ (&whole form &rest x)union$37867,1540274
(defun subst-for-nth-arg (new n args)subst-for-nth-arg37939,1543409
(defmacro the-mv (args type body &optional state-pos)the-mv37949,1543711
(defmacro the-mv (vars type body &optional state-pos)the-mv38003,1545645
(defmacro the2s (x y)the2s38014,1546189
(deflabel bibliographybibliography38017,1546238
(defun non-free-var-runes (runes free-var-runes-once free-var-runes-all acc)non-free-var-runes38038,1547040
(defun free-var-runes (flg wrld)free-var-runes38053,1547758
(defthm natp-position-ac ; for admission of absolute-pathname-string-pnatp-position-ac38061,1547977
(defun absolute-pathname-string-p (str directoryp os)absolute-pathname-string-p38069,1548313
(defun include-book-dir-alistp (x os)include-book-dir-alistp38115,1550440
(defun illegal-ruler-extenders-values (x wrld)illegal-ruler-extenders-values38124,1550755
(defun intersection-eq-exec (l1 l2)intersection-eq-exec38136,1551172
(defun intersection-eql-exec (l1 l2)intersection-eql-exec38148,1551588
(defun intersection-equal (l1 l2)intersection-equal38159,1552009
(defmacro intersection-eq (&rest lst)intersection-eq38169,1552331
(defthm intersection-eq-exec-is-intersection-equalintersection-eq-exec-is-intersection-equal38172,1552406
(defthm intersection-eql-exec-is-intersection-equalintersection-eql-exec-is-intersection-equal38176,1552534
(defmacro intersection$ (&whole form &rest x)intersection$38180,1552664
(defun table-alist (name wrld)table-alist38261,1556231
(defun ruler-extenders-msg-aux (vals return-last-table)ruler-extenders-msg-aux38269,1556461
(defun ruler-extenders-msg (x wrld)ruler-extenders-msg38286,1557229
(defmacro chk-ruler-extenders (x soft ctx wrld)chk-ruler-extenders38319,1558758
(defmacro fixnum-bound () ; most-positive-fixnum in Allegro CL and many othersfixnum-bound38329,1559215
(defconst *default-step-limit**default-step-limit*38332,1559315
(deflabel acl2-defaults-tableacl2-defaults-table38474,1564345
(defmacro set-enforce-redundancy (x)set-enforce-redundancy38788,1578037
(defmacro set-enforce-redundancy (x)set-enforce-redundancy38861,1581776
(defmacro set-ignore-doc-string-error (x)set-ignore-doc-string-error38866,1581861
(defmacro set-ignore-doc-string-error (x)set-ignore-doc-string-error38911,1583718
(defmacro default-verify-guards-eagerness-from-table (alist)default-verify-guards-eagerness-from-table38915,1583791
(defun default-verify-guards-eagerness (wrld)default-verify-guards-eagerness38919,1583920
(defmacro set-verify-guards-eagerness (x)set-verify-guards-eagerness38927,1584259
(defmacro set-verify-guards-eagerness (x)set-verify-guards-eagerness38983,1587101
(defun default-compile-fns (wrld)default-compile-fns38987,1587174
(defmacro set-compile-fns (x)set-compile-fns38993,1587431
(defmacro set-compile-fns (x)set-compile-fns39051,1589965
(defun set-compiler-enabled (val state)set-compiler-enabled39055,1590026
(defun default-measure-function (wrld)default-measure-function39080,1591110
(defmacro set-measure-function (name)set-measure-function39087,1591400
(defmacro set-measure-function (name)set-measure-function39127,1593020
(defun default-well-founded-relation (wrld)default-well-founded-relation39131,1593092
(defmacro set-well-founded-relation (rel)set-well-founded-relation39138,1593384
(defmacro set-well-founded-relation (rel)set-well-founded-relation39177,1595130
(defmacro default-defun-mode-from-table (alist)default-defun-mode-from-table39183,1595243
(defun default-defun-mode (wrld)default-defun-mode39193,1595542
(defun default-defun-mode-from-state (state)default-defun-mode-from-state39235,1597914
(defmacro logic nillogic39240,1598054
(defmacro logic () nil)logic39279,1599471
(defmacro program nilprogram39282,1599513
(defmacro program () nil)program39338,1601298
(defun invisible-fns-table (wrld)invisible-fns-table39340,1601325
(defmacro set-invisible-fns-table (alist)set-invisible-fns-table39388,1603431
(defun unary-function-symbol-listp (lst wrld)unary-function-symbol-listp39461,1606202
(defun invisible-fns-entryp (key val wrld)invisible-fns-entryp39479,1607001
(defmacro add-invisible-fns (top-fn &rest unary-fns)add-invisible-fns39491,1607320
(defmacro remove-invisible-fns (top-fn &rest unary-fns)remove-invisible-fns39533,1609171
(defmacro set-invisible-fns-alist (alist)set-invisible-fns-alist39578,1611065
(defmacro invisible-fns-alist (wrld)invisible-fns-alist39585,1611371
(defmacro set-bogus-defun-hints-ok (x)set-bogus-defun-hints-ok39592,1611606
(defmacro set-bogus-defun-hints-ok (x)set-bogus-defun-hints-ok39615,1612435
(defmacro set-bogus-mutual-recursion-ok (x)set-bogus-mutual-recursion-ok39620,1612522
(defmacro set-bogus-mutual-recursion-ok (x)set-bogus-mutual-recursion-ok39670,1614675
(defdoc ruler-extendersruler-extenders39674,1614750
(defmacro set-ruler-extenders (x)set-ruler-extenders40077,1631033
(defmacro set-ruler-extenders (x)set-ruler-extenders40102,1631939
(defmacro set-irrelevant-formals-ok (x)set-irrelevant-formals-ok40107,1632021
(defmacro set-irrelevant-formals-ok (x)set-irrelevant-formals-ok40142,1633262
(defmacro set-ignore-ok (x)set-ignore-ok40147,1633350
(defmacro set-ignore-ok (x)set-ignore-ok40191,1635028
(defmacro set-inhibit-warnings! (&rest x)set-inhibit-warnings!40196,1635104
(defmacro set-inhibit-warnings! (&rest lst)set-inhibit-warnings!40205,1635269
(defmacro set-inhibit-warnings (&rest lst)set-inhibit-warnings40224,1636033
(defmacro set-inhibit-output-lst (lst)set-inhibit-output-lst40274,1638350
(defmacro set-inhibited-summary-types (lst)set-inhibited-summary-types40342,1641563
(defmacro set-state-ok (x)set-state-ok40397,1643855
(defmacro set-state-ok (x)set-state-ok40470,1647025
(defmacro set-let*-abstractionp (x)set-let*-abstractionp40479,1647261
(defmacro set-let*-abstractionp (x)set-let*-abstractionp40526,1649168
(defmacro set-let*-abstraction (x)set-let*-abstraction40530,1649235
(defun let*-abstractionp (state)let*-abstractionp40538,1649469
(defconst *initial-backchain-limit* '(nil nil))*initial-backchain-limit*40552,1649965
(defconst *initial-default-backchain-limit* '(nil nil))*initial-default-backchain-limit*40554,1650014
(defmacro set-backchain-limit (limit)set-backchain-limit40557,1650088
(defmacro set-backchain-limit (limit)set-backchain-limit40610,1652460
(defun backchain-limit (wrld flg)backchain-limit40614,1652533
(defmacro set-default-backchain-limit (limit)set-default-backchain-limit40773,1659384
(defmacro set-default-backchain-limit (limit)set-default-backchain-limit40839,1662742
(defun default-backchain-limit (wrld flg)default-backchain-limit40843,1662823
(defun step-limit-from-table (wrld)step-limit-from-table40919,1666137
(defparameter *step-limit-error-p**step-limit-error-p*40938,1666945
(defmacro set-prover-step-limit (limit)set-prover-step-limit40947,1667223
(defmacro set-prover-step-limit (limit)set-prover-step-limit41109,1674603
(defparameter *rewrite-depth-max* 0)     ; records max depth per event*rewrite-depth-max*41128,1675340
(defparameter *rewrite-depth-alist* nil) ; records max depth per book*rewrite-depth-alist*41129,1675411
(defconst *default-rewrite-stack-limit**default-rewrite-stack-limit*41177,1677249
(defmacro set-rewrite-stack-limit (limit)set-rewrite-stack-limit41191,1677878
(defmacro set-rewrite-stack-limit (limit)set-rewrite-stack-limit41231,1679521
(defun rewrite-stack-limit (wrld)rewrite-stack-limit41235,1679598
(defmacro set-nu-rewriter-mode (x)set-nu-rewriter-mode41281,1681442
(defmacro set-nu-rewriter-mode (x)set-nu-rewriter-mode41335,1683791
(defun nu-rewriter-mode (wrld)nu-rewriter-mode41339,1683857
(defun case-split-limitations (wrld)case-split-limitations41359,1684822
(defmacro sr-limit (wrld)sr-limit41388,1686065
(defmacro case-limit (wrld)case-limit41391,1686133
(defmacro set-case-split-limitations (lst)set-case-split-limitations41395,1686221
(defmacro set-case-split-limitations (lst)set-case-split-limitations41537,1693686
(defconst *initial-acl2-defaults-table**initial-acl2-defaults-table*41548,1694158
(defun untrans-table (wrld)untrans-table41554,1694379
(defmacro add-macro-fn (macro macro-fn &optional right-associate-p)add-macro-fn41593,1695459
(defmacro add-binop (macro macro-fn)add-binop41636,1697642
(defmacro remove-macro-fn (macro-fn)remove-macro-fn41647,1697953
(defmacro remove-binop (macro-fn)remove-binop41676,1699116
(defun match-free-default (wrld)match-free-default41690,1699582
(defmacro set-match-free-default (x)set-match-free-default41698,1699913
(defmacro set-match-free-default (x)set-match-free-default41759,1702807
(defmacro set-match-free-error (x)set-match-free-error41763,1702875
(defun match-free-override (wrld)match-free-override41808,1705026
(defmacro add-match-free-override (flg &rest runes)add-match-free-override41826,1705785
(defmacro add-match-free-override (flg &rest runes)add-match-free-override42013,1715056
(defmacro add-include-book-dir (keyword dir)add-include-book-dir42017,1715147
(defmacro delete-include-book-dir (keyword)delete-include-book-dir42075,1718140
(defconst *non-linear-rounds-value* 3)*non-linear-rounds-value*42116,1719906
(defun non-linearp (wrld)non-linearp42118,1719946
(defmacro set-non-linearp (toggle)set-non-linearp42129,1720282
(defmacro set-non-linearp (toggle)set-non-linearp42153,1721007
(defmacro set-non-linear (toggle)set-non-linear42157,1721078
(defun tau-auto-modep (wrld)tau-auto-modep42165,1721304
(defmacro set-tau-auto-mode (toggle)set-tau-auto-mode42203,1722994
(defmacro set-tau-auto-mode (toggle)set-tau-auto-mode42323,1729780
(defmacro defttag (tag-name &key doc)defttag42328,1729870
(defmacro defttag (&rest args)defttag42595,1743346
(defun ttag (wrld)ttag42599,1743411
(defdoc complex-rationalpcomplex-rationalp42611,1743795
(deflabel letlet42625,1744243
(defdoc fletflet42750,1749814
(defun-one-output what-is-the-global-state ()what-is-the-global-state42880,1754866
(deflabel macro-aliases-tablemacro-aliases-table42947,1758021
(defun macro-aliases (wrld)macro-aliases43063,1762468
(defmacro add-macro-alias (macro-name fn-name)add-macro-alias43067,1762587
(defmacro remove-macro-alias (macro-name)remove-macro-alias43132,1765341
(deflabel nth-aliases-tablenth-aliases-table43165,1766710
(defun nth-aliases (wrld)nth-aliases43205,1768138
(defmacro add-nth-alias (alias-name name)add-nth-alias43209,1768253
(defmacro remove-nth-alias (alias-name)remove-nth-alias43230,1768903
(deflabel default-hints-tabledefault-hints-table43266,1770533
(defun default-hints (wrld)default-hints43287,1771299
(defmacro set-default-hints (lst)set-default-hints43312,1772261
(defmacro set-default-hints! (lst)set-default-hints!43371,1774670
(defmacro set-default-hints! (lst)set-default-hints!43389,1775370
(defmacro add-default-hints (lst &key at-end)add-default-hints43393,1775438
(defmacro add-default-hints! (lst &key at-end)add-default-hints!43442,1777579
(defmacro add-default-hints! (lst)add-default-hints!43462,1778433
(defmacro remove-default-hints (lst)remove-default-hints43466,1778501
(defmacro remove-default-hints! (lst)remove-default-hints!43506,1780044
(defmacro remove-default-hints! (lst)remove-default-hints!43524,1780826
(defmacro set-override-hints-macro (lst at-end ctx)set-override-hints-macro43529,1780914
(defmacro set-override-hints-macro (&rest args)set-override-hints-macro43535,1781137
(defmacro add-override-hints! (lst &key at-end)add-override-hints!43539,1781219
(defmacro add-override-hints (lst &key at-end)add-override-hints43553,1781721
(defmacro set-override-hints! (lst)set-override-hints!43583,1782993
(defmacro set-override-hints (lst)set-override-hints43596,1783434
(defmacro remove-override-hints! (lst)remove-override-hints!43620,1784291
(defmacro remove-override-hints (lst)remove-override-hints43633,1784792
(defmacro set-rw-cache-state (val)set-rw-cache-state43659,1785855
(defmacro set-rw-cache-state! (val)set-rw-cache-state!43937,1801305
(defmacro set-rw-cache-state! (val)set-rw-cache-state!43952,1801836
(defconst *legal-rw-cache-states**legal-rw-cache-states*43956,1801905
(defun fix-true-list (x)fix-true-list43965,1802110
(defthm pairlis$-fix-true-listpairlis$-fix-true-list43983,1802570
(defun boolean-listp (lst)boolean-listp43987,1802668
(defthm boolean-listp-consboolean-listp-cons43998,1802986
(defthm boolean-listp-forwardboolean-listp-forward44007,1803239
(defthm boolean-listp-forward-to-symbol-listpboolean-listp-forward-to-symbol-listp44017,1803502
(defaxiom completion-of-+completion-of-+44035,1804280
(defthm default-+-1default-+-144046,1804519
(defthm default-+-2default-+-244051,1804652
(defaxiom completion-of-*completion-of-*44056,1804785
(defthm default-*-1default-*-144065,1804972
(defthm default-*-2default-*-244069,1805058
(defaxiom completion-of-unary-minuscompletion-of-unary-minus44073,1805144
(defthm default-unary-minusdefault-unary-minus44080,1805281
(defaxiom completion-of-unary-/completion-of-unary-/44084,1805373
(defthm default-unary-/default-unary-/44092,1805548
(defaxiom completion-of-<completion-of-<44099,1805728
(defthm default-<-1default-<-144111,1806152
(defthm default-<-2default-<-244120,1806385
(defaxiom completion-of-carcompletion-of-car44129,1806618
(defthm default-cardefault-car44137,1806761
(defaxiom completion-of-cdrcompletion-of-cdr44141,1806842
(defthm default-cdrdefault-cdr44149,1806985
(defthm cons-car-cdrcons-car-cdr44153,1807066
(defaxiom completion-of-char-codecompletion-of-char-code44159,1807187
(defthm default-char-codedefault-char-code44166,1807336
(defaxiom completion-of-code-charcompletion-of-code-char44171,1807481
(defaxiom completion-of-complexcompletion-of-complex44192,1808076
(defthm default-complex-1default-complex-144200,1808303
(defthm default-complex-2default-complex-244208,1808536
(defthm complex-0complex-044217,1808858
(defthm add-def-complexadd-def-complex44225,1809073
(defthm realpart-+realpart-+44240,1809748
(defthm imagpart-+imagpart-+44245,1809878
(defaxiom completion-of-coercecompletion-of-coerce44250,1810008
(defthm default-coerce-1default-coerce-144261,1810271
(defthm make-character-list-make-character-listmake-character-list-make-character-list44267,1810454
(defthm default-coerce-2default-coerce-244271,1810593
(defthm default-coerce-3default-coerce-344285,1811151
(defaxiom completion-of-denominatorcompletion-of-denominator44291,1811335
(defthm default-denominatordefault-denominator44298,1811489
(defaxiom completion-of-floor1completion-of-floor144309,1811871
(defthm default-floor1default-floor144320,1812121
(defaxiom floor1-integer-xfloor1-integer-x44328,1812327
(defaxiom floor1-x-<=-xfloor1-x-<=-x44335,1812510
(defaxiom x-<-add1-floor1-xx-<-add1-floor1-x44343,1812704
(defthm floor1-valuefloor1-value44353,1813023
(defaxiom completion-of-imagpartcompletion-of-imagpart44361,1813213
(defthm default-imagpartdefault-imagpart44368,1813361
(defaxiom completion-of-intern-in-package-of-symbolcompletion-of-intern-in-package-of-symbol44373,1813475
(defaxiom completion-of-numeratorcompletion-of-numerator44392,1814135
(defthm default-numeratordefault-numerator44399,1814283
(defaxiom completion-of-realpartcompletion-of-realpart44404,1814396
(defthm default-realpartdefault-realpart44411,1814544
(defaxiom completion-of-symbol-namecompletion-of-symbol-name44416,1814658
(defthm default-symbol-namedefault-symbol-name44423,1814811
(defaxiom completion-of-symbol-package-namecompletion-of-symbol-package-name44429,1814978
(defthm default-symbol-package-namedefault-symbol-package-name44436,1815155
(defdoc i-smalli-small44445,1815435
(defdoc i-closei-close44454,1815684
(defdoc i-largei-large44462,1815939
(defdoc i-limitedi-limited44471,1816202
(defdoc standardpstandardp44480,1816450
(defdoc standard-partstandard-part44501,1817475
(defun i-small (x)i-small44513,1817830
(defun i-close (x y)i-close44518,1817940
(defun i-large (x)i-large44524,1818066
(defmacro i-limited (x)i-limited44530,1818189
(defaxiom i-large-integer-is-largei-large-integer-is-large44537,1818404
(defaxiom standardp-plusstandardp-plus44545,1818691
(defaxiom standardp-uminusstandardp-uminus44550,1818811
(defaxiom standardp-timesstandardp-times44554,1818897
(defaxiom standardp-udividestandardp-udivide44559,1819018
(defaxiom standardp-complexstandardp-complex44563,1819105
(defaxiom standardp-onestandardp-one44571,1819423
(defaxiom standard-part-of-standardpstandard-part-of-standardp44577,1819547
(defaxiom standardp-standard-partstandardp-standard-part44582,1819690
(defaxiom standard-part-of-reals-is-idempotentstandard-part-of-reals-is-idempotent44586,1819793
(defaxiom standard-part-of-complexstandard-part-of-complex44591,1819953
(defaxiom standard-part-of-plusstandard-part-of-plus44597,1820131
(defaxiom standard-part-of-uminusstandard-part-of-uminus44602,1820272
(defaxiom standard-part-of-timesstandard-part-of-times44606,1820377
(defaxiom standard-part-of-udividestandard-part-of-udivide44611,1820559
(defaxiom standard-part-<=standard-part-<=44617,1820743
(defaxiom small-are-limitedsmall-are-limited44623,1820903
(defaxiom standards-are-limitedstandards-are-limited44630,1821079
(defthm standard-constants-are-limitedstandard-constants-are-limited44636,1821248
(defaxiom limited-integers-are-standardlimited-integers-are-standard44644,1821497
(defaxiom standard+small->i-limitedstandard+small->i-limited44651,1821733
(defdoc acl2-numberpacl2-numberp44659,1821917
(defdoc ++44667,1822123
(defdoc binary-+binary-+44683,1822432
(defdoc binary-*binary-*44709,1823042
(defdoc --44733,1823606
(defdoc unary--unary--44762,1824097
(defdoc unary-/unary-/44784,1824601
(defdoc <<44808,1825165
(defdoc carcar44838,1826076
(defdoc cdrcdr44857,1826488
(defdoc char-codechar-code44876,1826902
(defdoc characterpcharacterp44894,1827285
(defdoc code-charcode-char44902,1827453
(defdoc complexcomplex44925,1828008
(defdoc conscons44973,1829829
(defdoc conspconsp44982,1830112
(defdoc coercecoerce44989,1830273
(defdoc denominatordenominator45038,1831924
(defdoc equalequal45056,1832266
(defdoc ifif45067,1832547
(defdoc imagpartimagpart45083,1832959
(defdoc integerpintegerp45101,1833292
(defdoc intern-in-package-of-symbolintern-in-package-of-symbol45108,1833451
(defdoc numeratornumerator45164,1835666
(defdoc rationalprationalp45182,1835999
(defdoc realpartrealpart45190,1836195
(defdoc stringpstringp45208,1836523
(defdoc symbol-namesymbol-name45215,1836672
(defdoc symbol-package-namesymbol-package-name45233,1837010
(defdoc symbolpsymbolp45260,1837962
(defdoc quotequote45267,1838111
(defun double-rewrite (x)double-rewrite45275,1838276
(defparameter *acl2-time-limit* nil)*acl2-time-limit*45508,1849241
(defparameter *acl2-time-limit-boundp* nil)*acl2-time-limit-boundp*45510,1849279
(defun chk-with-prover-time-limit-arg (time)chk-with-prover-time-limit-arg45514,1849327
(defmacro with-prover-time-limit1-raw (time form)with-prover-time-limit1-raw45531,1850000
(defmacro with-prover-time-limit1 (time form)with-prover-time-limit145551,1850875
(defmacro with-prover-time-limit (time form)with-prover-time-limit45554,1850981
(defparameter *time-limit-tags* nil)*time-limit-tags*45651,1855899
(defmacro catch-time-limit5 (form)catch-time-limit545653,1855937
(defmacro catch-time-limit5@par (form)catch-time-limit5@par45677,1856921
(defun time-limit5-reached-p (msg)time-limit5-reached-p45713,1858555
(defmacro catch-step-limit (form)catch-step-limit45757,1860594
(defconst *guard-checking-values**guard-checking-values*45786,1861789
(defun chk-with-guard-checking-arg (val)chk-with-guard-checking-arg45789,1861855
(defmacro with-guard-checking1-raw (val form)with-guard-checking1-raw45801,1862374
(defmacro with-guard-checking1 (val form)with-guard-checking145812,1862770
(defmacro with-guard-checking (val form)with-guard-checking45815,1862868
(defun abort! ()abort!45841,1863807
(defmacro a! ()a!45855,1864110
(defun p! ()p!45879,1864978
(defparameter *wormhole-status-alist* nil)*wormhole-status-alist*45922,1866667
(defparameter *inhibit-wormhole-activityp* nil)*inhibit-wormhole-activityp*45925,1866728
(defun wormhole1 (name input form ld-specials)wormhole145927,1866777
(defun wormhole-p (state)wormhole-p46023,1870784
(defun duplicates (lst)duplicates46040,1871264
(defun evens (l)evens46047,1871497
(defun odds (l)odds46053,1871643
(defun set-equalp-equal (lst1 lst2)set-equalp-equal46057,1871721
(defparameter *metafunction-context* nil)*metafunction-context*46179,1878667
(DEFMACRO |Access REWRITE-CONSTANT record field CURRENT-CLAUSE||Access46299,1883189
(defun record-error (name rec)record-error46316,1883760
(defun record-accessor-function-name (name field)record-accessor-function-name46322,1883930
(defmacro access (name rec field)access46334,1884315
(defun mfc-clause (mfc)mfc-clause46343,1884655
(defun mfc-rdepth (mfc)mfc-rdepth46377,1886053
(defun type-alist-entryp (x)type-alist-entryp46387,1886348
(defun type-alistp (x)type-alistp46403,1886836
(defun mfc-type-alist (mfc)mfc-type-alist46410,1886995
(defun mfc-ancestors (mfc)mfc-ancestors46426,1887438
(defun mfc-unify-subst (mfc)mfc-unify-subst46442,1887875
(defun mfc-world (mfc)mfc-world46452,1888190
(defthm pseudo-term-listp-mfc-clausepseudo-term-listp-mfc-clause46465,1888561
(defthm type-alistp-mfc-type-alisttype-alistp-mfc-type-alist46468,1888639
(defun bad-atom (x)bad-atom46503,1890631
(defthm bad-atom-compound-recognizerbad-atom-compound-recognizer46514,1890849
(defun-one-output bad-atom<= (x y)bad-atom<=46526,1891143
(defaxiom booleanp-bad-atom<=booleanp-bad-atom<=46535,1891497
(defaxiom bad-atom<=-antisymmetricbad-atom<=-antisymmetric46540,1891633
(defaxiom bad-atom<=-transitivebad-atom<=-transitive46548,1891839
(defaxiom bad-atom<=-totalbad-atom<=-total46557,1892102
(defun alphorder (x y)alphorder46567,1892372
(defun lexorder (x y)lexorder46643,1894975
(defthm alphorder-reflexivealphorder-reflexive46708,1897027
(defthm alphorder-transitivealphorder-transitive46725,1897544
(defthm alphorder-anti-symmetricalphorder-anti-symmetric46736,1897878
(defthm alphorder-totalalphorder-total46760,1898893
(defthm lexorder-reflexivelexorder-reflexive46775,1899430
(defthm lexorder-anti-symmetriclexorder-anti-symmetric46778,1899476
(defthm lexorder-transitivelexorder-transitive46783,1899615
(defthm lexorder-totallexorder-total46788,1899765
(defun merge-lexorder (l1 l2 acc)merge-lexorder46804,1900296
(defthm true-listp-merge-sort-lexordertrue-listp-merge-sort-lexorder46830,1901044
(defun merge-sort-lexorder (l)merge-sort-lexorder46836,1901237
(defdoc bddbdd46851,1901863
(defun if* (x y z)if*46885,1903313
(defun resize-list (lst n default-value)resize-list47069,1910463
(deflabel theory-functionstheory-functions47085,1910983
(defun e/d-fn (theory e/d-list enable-p)e/d-fn47120,1912606
(defmacro e/d (&rest theories)e/d47131,1913127
(defun mod-expt (base exp mod)mod-expt47210,1916110
(defmacro fcons-term* (&rest x)fcons-term*47254,1917883
(defun conjoin2 (t1 t2)conjoin247271,1918561
(defun conjoin (l)conjoin47285,1919059
(defun conjoin2-untranslated-terms (t1 t2)conjoin2-untranslated-terms47291,1919228
(defun conjoin-untranslated-terms (l)conjoin-untranslated-terms47307,1919670
(defun disjoin2 (t1 t2)disjoin247319,1920009
(defun disjoin (lst)disjoin47331,1920367
(defun disjoin-lst (clause-list)disjoin-lst47337,1920552
(defun conjoin-clauses (clause-list)conjoin-clauses47343,1920774
(defconst *true-clause* (list *t*))*true-clause*47347,1920908
(defconst *false-clause* nil)*false-clause*47349,1920945
(defun clauses-result (tuple)clauses-result47351,1920976
(defdoc sharp-dot-readersharp-dot-reader47356,1921124
(defdoc sharp-comma-readersharp-comma-reader47395,1922413
(defdoc sharp-bang-readersharp-bang-reader47403,1922618
(defdoc sharp-u-readersharp-u-reader47435,1923416
(defdoc evisc-tableevisc-table47487,1924950
(defconst *top-hint-keywords**top-hint-keywords*47731,1933483
(defconst *hint-keywords**hint-keywords*47741,1933891
(defmacro add-custom-keyword-hint (key uterm1 &key (checker '(value t)))add-custom-keyword-hint47786,1935294
(defmacro add-custom-keyword-hint (&rest args)add-custom-keyword-hint47874,1939078
(defmacro remove-custom-keyword-hint (keyword)remove-custom-keyword-hint47878,1939159
(defun splice-keyword-alist (key new-segment keyword-alist)splice-keyword-alist47911,1940296
(deflabel custom-keyword-hintscustom-keyword-hints47924,1940838
(defmacro show-custom-keyword-hint-expansion (flg)show-custom-keyword-hint-expansion47934,1941150
(defun search-fn-guard (seq1 seq2 from-end test start1 start2 end1 end2search-fn-guard47963,1942030
(defun search-from-start (seq1 seq2 start2 end2)search-from-start48011,1944178
(defun search-from-end (seq1 seq2 start2 end2 acc)search-from-end48034,1945038
(defmacro search (seq1 seq2search48215,1950694
(defthm eqlablep-ntheqlablep-nth48279,1953737
(defun count-stringp (item x start end)count-stringp48284,1953866
(defun count-listp (item x end)count-listp48299,1954399
(defmacro count (item sequence &key (start '0) end)count48334,1955531
(defun make-sharp-atsign (i)make-sharp-atsign48374,1957123
(defun sharp-atsign-alist (i acc)sharp-atsign-alist48381,1957339
(defmacro time$1-raw (val x)time$1-raw48488,1962299
(defmacro time$1 (val form)time$148508,1962982
(defmacro time$ (x &keytime$48511,1963052
(defmacro our-multiple-value-prog1 (form &rest other-forms)our-multiple-value-prog148693,1969769
(defconst *mv-vars**mv-vars*48709,1970257
(defconst *mv-var-values**mv-var-values*48716,1970402
(defconst *mv-extra-var* (gensym))*mv-extra-var*48720,1970496
(defun protect-mv (form &optional multiplicity)protect-mv48722,1970532
(defmacro our-time (x &key real-mintime run-mintime minalloc msg args)our-time48770,1972296
(defun-one-output gc$-fn (args)gc$-fn48905,1978237
(defun gc$-fn (args)gc$-fn48929,1979081
(defmacro gc$ (&rest args)gc$48934,1979164
(defun-one-output gc-verbose-fn (arg)gc-verbose-fn48963,1980149
(defun gc-verbose-fn (arg)gc-verbose-fn48978,1980617
(defmacro gc-verbose (arg)gc-verbose48983,1980705
(defun get-wormhole-status (name state)get-wormhole-status49008,1981600
(defun file-write-date$ (file state)file-write-date$49037,1982694
(defun debugger-enable (state)debugger-enable49055,1983206
(defun break$ ()break$49060,1983397
(defvar *ccl-print-call-history-count**ccl-print-call-history-count*49096,1984582
(defun print-call-history ()print-call-history49119,1985629
(defun debugger-enabledp (state)debugger-enabledp49170,1987549
(defun maybe-print-call-history (state)maybe-print-call-history49177,1987825
(defmacro with-reckless-readtable (form)with-reckless-readtable49184,1988116
(defmacro set-debugger-enable (val)set-debugger-enable49202,1988723
(defun set-debugger-enable-fn (val state)set-debugger-enable-fn49336,1994614
(defun add-@par-suffix (symbol)add-@par-suffix49369,1995976
(defun generate-@par-mappings (symbols)generate-@par-mappings49375,1996151
(defconst *@par-mappings**@par-mappings*49392,1996996
(defun make-identity-for-@par-mappings (mappings)make-identity-for-@par-mappings49586,2003846
(defmacro define-@par-macros ()define-@par-macros49600,2004411
(defun replace-defun@par-with-defun (forms)replace-defun@par-with-defun49617,2005007
(defmacro mutual-recursion@par (&rest forms)mutual-recursion@par49628,2005374
(defun defun@par-fn (name parallel-version rst)defun@par-fn49632,2005493
(defun mutual-recursion@par-guardp (rst)mutual-recursion@par-guardp49652,2006235
(defun mutual-recursion@par-fn (forms serial-and-par)mutual-recursion@par-fn49664,2006717
(defmacro mutual-recursion@par (&rest forms)mutual-recursion@par49686,2007678
(defmacro defun@par (name &rest args)defun@par49690,2007846
(defmacro serial-first-form-parallel-second-form (x y)serial-first-form-parallel-second-form49704,2008344
(defmacro serial-first-form-parallel-second-form@par (x y)serial-first-form-parallel-second-form@par49712,2008505
(defmacro serial-only (x)serial-only49719,2008655
(defmacro serial-only@par (x)serial-only@par49726,2008737
(defmacro parallel-only (x)parallel-only49733,2008833
(defmacro parallel-only@par (x)parallel-only@par49741,2008944
(defmacro mv@par (&rest rst)mv@par49748,2009030
(defmacro value@par (val)value@par49754,2009190
(defmacro state-mac ()state-mac49760,2009264
(defmacro state-mac@par ()state-mac@par49767,2009346
(defmacro mv-let@par (vars call &rest rst)mv-let@par49774,2009425
(defmacro warning$@par (&rest rst)warning$@par49780,2009616
(defmacro error-in-parallelism-mode (fake-return-value form)error-in-parallelism-mode49789,2009865
(defmacro error-in-parallelism-mode@par (return-value form)error-in-parallelism-mode@par49794,2009985
(defun increment-timer@par (name state)increment-timer@par49816,2010898
(defconst *waterfall-printing-values**waterfall-printing-values*49824,2011124
(defconst *waterfall-parallelism-values**waterfall-parallelism-values*49827,2011198
(defun symbol-constant-fn (prefix sym)symbol-constant-fn49834,2011426
(defun stobjs-in (fn w)stobjs-in49845,2011779
(defmacro oracle-funcall (fn &rest args)oracle-funcall49860,2012183
(defun all-nils (lst)all-nils49894,2013291
(defun oracle-apply-guard (fn args state)oracle-apply-guard49900,2013457
(defun oracle-apply (fn args state)oracle-apply49913,2013951
(defun oracle-apply-raw (fn args state)oracle-apply-raw50039,2019586
(defun time-tracker-fn (tag kwd kwdp times interval min-time msg)time-tracker-fn50074,2021042
(defmacro time-tracker (tag &optional (kwd 'nil kwdp)time-tracker50143,2023353
(defmacro time-tracker (&rest args)time-tracker50148,2023551
(defdoc time-trackertime-tracker50152,2023621
(defdoc time-tracker-tautime-tracker-tau50397,2036637
(defg *inside-absstobj-update* #(0))*inside-absstobj-update*50464,2039234
(defun set-absstobj-debug-fn (val always)set-absstobj-debug-fn50466,2039272
(defmacro set-absstobj-debug (val &key (event-p 't) always on-skip-proofs)set-absstobj-debug50497,2040704
(defun <? (rel x y)<?50735,2050854
(defun tau-interval-domainp (dom x)tau-interval-domainp50769,2052020
(defun tau-interval-dom (x)tau-interval-dom50777,2052276
(defun tau-interval-lo-rel (x)tau-interval-lo-rel50798,2052844
(defun tau-interval-lo (x)tau-interval-lo50820,2053592
(defun tau-interval-hi-rel (x)tau-interval-hi-rel50842,2054291
(defun tau-interval-hi (x)tau-interval-hi50863,2055038
(defun make-tau-interval (dom lo-rel lo hi-rel hi)make-tau-interval50885,2055737
(defun tau-intervalp (int)tau-intervalp50945,2058480
(defun in-tau-intervalp (x int)in-tau-intervalp51057,2062639

memoize.lisp,1304
(defmacro defn (f a &rest r)defn31,1268
(defmacro defnd (f a &rest r)defnd40,1466
(defdoc hons-and-memoizationhons-and-memoization49,1682
(defn clear-memoize-table (fn)clear-memoize-table364,17583
(defn clear-memoize-tables ()clear-memoize-tables379,18018
(defn memoize-summary ()memoize-summary395,18526
(defn clear-memoize-statistics ()clear-memoize-statistics410,19062
(defmacro memsum ()memsum423,19510
(defconst *hons-primitive-fns**hons-primitive-fns*444,20337
(defconst *hons-primitives**hons-primitives*473,20939
(defconst *mht-default-size* 60)*mht-default-size*484,21211
(defun memoize-form (fnmemoize-form486,21245
(defmacro memoize (fn &keymemoize634,28081
(defmacro unmemoize (fn)unmemoize921,43447
(defmacro profile (fn &rest r)profile972,45052
(defmacro memoize-on-raw (fn form)memoize-on-raw1025,47519
(defmacro memoize-on (fn form)memoize-on1029,47587
(defmacro memoize-off-raw (fn form)memoize-off-raw1040,47969
(defmacro memoize-off (fn form)memoize-off1044,48038
(defmacro memoizedp-world (fn wrld)memoizedp-world1054,48412
(defmacro memoizedp (fn)memoizedp1065,48789
(defparameter *never-profile-ht**never-profile-ht*1094,49641
(defun never-memoize-fn (fn)never-memoize-fn1098,49739
(defmacro never-memoize (fn)never-memoize1103,49842

hons.lisp,2416
(defdoc normednormed35,1575
(defn hons-copy (x)hons-copy102,4467
(defn hons-copy-persistent (x)hons-copy-persistent141,6056
(defn hons (x y)hons164,6943
(defn hons-equal (x y)hons-equal196,8130
(defn hons-equal-lite (x y)hons-equal-lite222,9274
(defn hons-clear (gc)hons-clear248,10388
(defn hons-wash ()hons-wash282,11784
(defn hons-summary ()hons-summary316,13304
(defmacro hons-resize (&key str-ht nil-ht cdr-ht cdr-ht-eqlhons-resize339,14200
(defn hons-resize-fn (str-ht nil-ht cdr-ht cdr-ht-eqlhons-resize-fn418,17291
(defdoc hons-notehons-note427,17635
(defdoc fast-alistsfast-alists491,20704
(defn hons-assoc-equal (key alist)hons-assoc-equal541,23198
(defdoc slow-alist-warningslow-alist-warning566,24187
(defmacro set-slow-alist-action (action)set-slow-alist-action595,25401
(defn get-slow-alist-action (state)get-slow-alist-action601,25631
(defn hons-get (key alist)hons-get609,25900
(defn hons-acons (key val alist)hons-acons631,26829
(defn hons-acons! (key val alist)hons-acons!697,29794
(defn make-fast-alist (alist)make-fast-alist761,32457
(defn hons-shrink-alist (alist ans)hons-shrink-alist786,33535
(defn hons-shrink-alist! (alist ans)hons-shrink-alist!861,36559
(defn fast-alist-len (alist)fast-alist-len882,37448
(defn fast-alist-free (alist)fast-alist-free902,38282
(defn fast-alist-summary ()fast-alist-summary932,39428
(defdoc with-fast-alistwith-fast-alist951,40128
(defdoc with-stolen-alistwith-stolen-alist1020,42528
(defdoc fast-alist-free-on-exitfast-alist-free-on-exit1041,43539
(defined in the community book ~c[\"books/tools/bstar.lisp\"]) with thein1063,44348
(defmacro with-fast-alist-raw (alist form)with-fast-alist-raw1078,44776
(defmacro with-fast-alist (alist form)with-fast-alist1083,44897
(defmacro with-stolen-alist-raw (alist form)with-stolen-alist-raw1087,45022
(defmacro with-stolen-alist (alist form)with-stolen-alist1092,45145
(defmacro fast-alist-free-on-exit-raw (alist form)fast-alist-free-on-exit-raw1096,45274
(defmacro fast-alist-free-on-exit (alist form)fast-alist-free-on-exit1101,45403
(defn cons-subtrees (x al)cons-subtrees1104,45511
(defn number-subtrees (x)number-subtrees1124,46064
(defn clear-hash-tables ()clear-hash-tables1143,46734
(defn flush-hons-get-hash-table-link (alist)flush-hons-get-hash-table-link1157,47179
(defun remove-keyword (word l)remove-keyword1200,48972

serialize.lisp,548
(defdoc serializeserialize38,1448
(defmacro serialize-write (filename obj &key verbosep)serialize-write55,2188
(defun serialize-write-fn (filename obj verbosep state)serialize-write-fn84,3117
(defmacro serialize-read (filename &keyserialize-read117,4200
(defun serialize-read-fn (filename hons-mode verbosep state)serialize-read-fn160,6021
(defdoc serialize-alternativesserialize-alternatives196,7254
(defdoc serialize-in-booksserialize-in-books212,7966
(defmacro with-serialize-character (val form)with-serialize-character255,9650

basis.lisp,32644
(defun enforce-redundancy-er-args (event-form-var wrld-var)enforce-redundancy-er-args39,1746
(defmacro enforce-redundancy (event-form ctx wrld form)enforce-redundancy48,2209
(defdoc gclgcl71,3270
(defun wormhole-statusp (whs)wormhole-statusp307,14303
(defun wormhole-entry-code (whs)wormhole-entry-code326,14818
(defun wormhole-data (whs)wormhole-data345,15378
(defun set-wormhole-entry-code (whs code)set-wormhole-entry-code361,15809
(defun set-wormhole-data (whs data)set-wormhole-data388,16833
(defun make-wormhole-status (old-status new-code new-data)make-wormhole-status412,17694
(defun tree-occur-eq (x y)tree-occur-eq471,20320
(defun wormhole-eval (qname qlambda free-vars)wormhole-eval482,20570
(deflock *wormhole-lock*)*wormhole-lock*585,25641
(defmacro wormhole-eval (qname qlambda free-vars)wormhole-eval588,25685
(defmacro wormhole (name entry-lambda input formwormhole644,28280
(deflabel wormhole-implementationwormhole-implementation1153,52622
(defun global-set (var val wrld)global-set1236,57113
(defun defabbrev1 (lst)defabbrev11241,57284
(defun legal-variable-or-constant-namep (name)legal-variable-or-constant-namep1247,57486
(defun legal-constantp1 (name)legal-constantp11313,60403
(defun tilde-@-illegal-variable-or-constant-name-phrase (name)tilde-@-illegal-variable-or-constant-name-phrase1328,60900
(defun legal-constantp (name)legal-constantp1359,62579
(defun defined-constant (name w)defined-constant1369,62893
(defun legal-variablep (name)legal-variablep1386,63632
(defun genvar1 (pkg-witness char-lst avoid-lst cnt)genvar11394,63917
(defun genvar (pkg-witness prefix n avoid-lst)genvar1430,65693
(defun packn1 (lst)packn11472,67877
(defun packn (lst)packn1478,68061
(defun packn-pos (lst witness)packn-pos1486,68306
(defun pack2 (n1 n2)pack21492,68543
(defun gen-formals-from-pretty-flags1 (pretty-flags i avoid)gen-formals-from-pretty-flags11495,68589
(defun gen-formals-from-pretty-flags (pretty-flags)gen-formals-from-pretty-flags1520,69612
(defun defstub-body (output)defstub-body1532,70206
(defun collect-non-x (x lst)collect-non-x1555,71040
(defmacro defproxy (name args-sig arrow body-sig)defproxy1567,71419
(defmacro defproxy (name args-sig arrow body-sig)defproxy1904,83267
(defun defstub-ignores (formals body)defstub-ignores1920,84051
(defun partition-rest-and-keyword-args1 (x)partition-rest-and-keyword-args11944,84928
(defun partition-rest-and-keyword-args2 (keypart keys alist)partition-rest-and-keyword-args21953,85229
(defun partition-rest-and-keyword-args (x keys)partition-rest-and-keyword-args1970,85925
(defmacro defstub (name &rest rst)defstub1989,86715
(defun lambda-keywordp (x)lambda-keywordp2093,91423
(defun arglistp1 (lst)arglistp12097,91518
(defun arglistp (lst)arglistp2105,91707
(defun find-first-bad-arg (args)find-first-bad-arg2109,91783
(defun process-defabbrev-declares (decls)process-defabbrev-declares2137,93152
(defmacro defabbrev (fn args &rest body)defabbrev2160,94234
(defconst *primitive-formals-and-guards**primitive-formals-and-guards*2297,100498
(defconst *primitive-monadic-booleans**primitive-monadic-booleans*2376,103524
(defun equal-x-constant (x const)equal-x-constant2399,104125
(defun match-tests-and-bindings (x pat tests bindings)match-tests-and-bindings2415,104592
(defun match-clause (x pat forms)match-clause2489,107916
(defun match-clause-list (x clauses)match-clause-list2497,108164
(defmacro case-match (&rest args)case-match2505,108475
(defconst *non-standard-primitives**non-standard-primitives*2588,111876
(defun cons-term1-cases (alist)cons-term1-cases2593,111967
(defconst *cons-term1-alist**cons-term1-alist*2641,114155
(defmacro cons-term1-body ()cons-term1-body2644,114238
(defun quote-listp (l)quote-listp2653,114505
(defun cons-term1 (fn args)cons-term12659,114667
(defun cons-term (fn args)cons-term2664,114824
(defmacro cons-term* (fn &rest args)cons-term*2670,114992
(defmacro mcons-term (fn args)mcons-term2673,115064
(defmacro mcons-term* (fn &rest args)mcons-term*2680,115241
(defmacro fcons-term (fn args)fcons-term2687,115432
(defun fargn1 (x n)fargn12704,116093
(defmacro fargn (x n)fargn2710,116277
(defun cdr-nest (n v)cdr-nest2713,116328
(defun all-but-last (l)all-but-last2717,116402
(defconst *evisceration-mark* :evisceration-mark)*evisceration-mark*2753,118211
(defconst *evisceration-hash-mark* (cons *evisceration-mark* "#"))*evisceration-hash-mark*2763,118712
(defconst *evisceration-ellipsis-mark* (cons *evisceration-mark* "..."))*evisceration-ellipsis-mark*2764,118779
(defconst *evisceration-world-mark**evisceration-world-mark*2765,118852
(defconst *evisceration-state-mark**evisceration-state-mark*2767,118928
(defconst *evisceration-error-triple-marks**evisceration-error-triple-marks*2769,119004
(defconst *evisceration-hiding-mark**evisceration-hiding-mark*2771,119092
(defconst *anti-evisceration-mark**anti-evisceration-mark*2774,119171
(defmacro evisceratedp (eviscp x)evisceratedp2777,119258
(defconst *sharp-atsign-ar* ; see get-sharp-atsign*sharp-atsign-ar*2863,124331
(defun get-sharp-atsign (i)get-sharp-atsign2872,124706
(defun update-iprint-alist (iprint-alist val)update-iprint-alist2882,125044
(defun eviscerate1 (x v max-v max-n alist evisc-table hiding-cars iprint-alist)eviscerate12902,125827
(defun eviscerate1-lst (lst v n max-v max-n alist evisc-table hiding-carseviscerate1-lst2934,127338
(defun eviscerate1p (x alist evisc-table hiding-cars)eviscerate1p2968,128714
(defun eviscerate1p-lst (lst alist evisc-table hiding-cars)eviscerate1p-lst2984,129387
(defun eviscerate (x print-level print-length alist evisc-table hiding-carseviscerate2996,129865
(defun eviscerate-simple (x print-level print-length alist evisc-tableeviscerate-simple3056,132481
(defun aset1-lst (name alist ar)aset1-lst3068,132969
(defun iprint-hard-bound (state)iprint-hard-bound3078,133284
(defun iprint-soft-bound (state)iprint-soft-bound3081,133361
(defun iprint-last-index* (iprint-ar)iprint-last-index*3084,133438
(defun iprint-last-index (state)iprint-last-index3091,133648
(defun iprint-ar-illegal-index (index state)iprint-ar-illegal-index3094,133738
(defun iprint-enabledp (state)iprint-enabledp3103,134081
(defun iprint-ar-aref1 (index state)iprint-ar-aref13106,134176
(defun collect-posp-indices-to-header (ar acc)collect-posp-indices-to-header3129,134951
(defun rollover-iprint-ar (iprint-alist last-index state)rollover-iprint-ar3145,135544
(defun update-iprint-ar (iprint-alist state)update-iprint-ar3218,139011
(defun eviscerate-top (x print-level print-length alist evisc-table hiding-carseviscerate-top3241,139990
(defun world-evisceration-alist (state alist)world-evisceration-alist3258,140812
(defun stobj-print-name (name)stobj-print-name3265,141040
(defun evisceration-stobj-mark (name inputp)evisceration-stobj-mark3272,141204
(defun evisceration-stobj-marks1 (stobjs-flags inputp)evisceration-stobj-marks13284,141516
(defconst *error-triple-sig**error-triple-sig*3296,141924
(defconst *cmp-sig**cmp-sig*3299,141974
(defun evisceration-stobj-marks (stobjs-flags inputp)evisceration-stobj-marks3302,142009
(defun eviscerate-stobjs1 (estobjs-out lst print-level print-lengtheviscerate-stobjs13310,142319
(defun eviscerate-stobjs (estobjs-out lst print-level print-lengtheviscerate-stobjs3331,143383
(defun eviscerate-stobjs-top (estobjs-out lst print-level print-lengtheviscerate-stobjs-top3380,145437
(defmacro mv-letc (vars form body)mv-letc3452,149388
(defmacro er-hard-val (val &rest args)er-hard-val3457,149515
(defmacro the-fixnum! (n ctx)the-fixnum!3467,149859
(defmacro the-half-fixnum! (n ctx)the-half-fixnum!3485,150433
(defmacro the-unsigned-byte! (bits n ctx)the-unsigned-byte!3503,151064
(defmacro the-string! (s ctx)the-string!3512,151369
(defun xxxjoin-fixnum (fn args root)xxxjoin-fixnum3519,151533
(defmacro +f (&rest args)+f3534,151937
(defmacro -f (arg1 &optional arg2)-f3537,151994
(defmacro 1-f (x)1-f3543,152168
(defmacro 1+f (x)1+f3547,152249
(defmacro charf (s i)charf3551,152330
(defmacro *f (&rest args)*f3555,152404
(defmacro ppr-flat-right-margin ()ppr-flat-right-margin3846,164443
(defun set-ppr-flat-right-margin (val state)set-ppr-flat-right-margin3849,164527
(defun keyword-param-valuep (tuple eviscp)keyword-param-valuep3862,165093
(defun cons-ppr1 (x column width ppr-flat-right-margin eviscp)cons-ppr13882,166050
(defun flsz-integer (x print-base acc)flsz-integer4024,172041
(defun flsz-atom (x print-base print-radix acc state)flsz-atom4034,172419
(defun flsz1 (x print-base print-radix j maximum state eviscp)flsz14110,175693
(defun output-in-infixp (state)output-in-infixp4143,177007
(defun flatsize-infix (x print-base print-radix termp j max state eviscp)flatsize-infix4147,177129
(defun flsz (x termp j maximum state eviscp)flsz4163,177843
(defun max-width (lst maximum)max-width4169,178107
(defun ppr1 (x print-base print-radix width rpc state eviscp)ppr14177,178318
(defun ppr1-lst (lst print-base print-radix width rpc state eviscp)ppr1-lst4272,182625
(defun newline (channel state)newline4318,184618
(defun fmt-hard-right-margin (state)fmt-hard-right-margin4321,184686
(defun fmt-soft-right-margin (state)fmt-soft-right-margin4325,184787
(defun set-fmt-hard-right-margin (n state)set-fmt-hard-right-margin4329,184888
(defun set-fmt-soft-right-margin (n state)set-fmt-soft-right-margin4365,186216
(defun write-for-read (state)write-for-read4387,186872
(defun spaces1 (n col hard-right-margin channel state)spaces14390,186943
(defun make-spaces-array-rec (n acc)make-spaces-array-rec4407,187664
(defun make-spaces-array (n)make-spaces-array4417,187891
(defconst *acl2-built-in-spaces-array**acl2-built-in-spaces-array*4426,188197
(defun spaces (n col channel state)spaces4432,188320
(defun flpr1 (x channel state eviscp)flpr14454,189075
(defun flpr11 (x channel state eviscp)flpr114467,189538
(defun-one-output print-flat-infix (x termp file eviscp)print-flat-infix4484,190041
(defun flpr (x termp channel state eviscp)flpr4498,190549
(defun ppr2-flat (x channel state eviscp)ppr2-flat4510,190952
(defun ppr2-column (lst loc col channel state eviscp)ppr2-column4530,191604
(defun ppr2 (x col channel state eviscp)ppr24547,192305
(defconst *fmt-ppr-indentation* 0)*fmt-ppr-indentation*4594,194264
(defun ppr (x col channel state eviscp)ppr4596,194300
(defun scan-past-whitespace (s i maximum)scan-past-whitespace4622,195348
(defun zero-one-or-more (x)zero-one-or-more4632,195675
(defun find-alternative-skip (s i maximum)find-alternative-skip4640,195844
(defun find-alternative-start1 (x s i maximum)find-alternative-start14678,197321
(defun fmt-char (s i j maximum err-flg)fmt-char4721,199281
(defun find-alternative-start (x s i maximum)find-alternative-start4743,200133
(defun find-alternative-stop (s i maximum)find-alternative-stop4775,201603
(defun punctp (c)punctp4811,203118
(defun fmt-tilde-s1 (s i maximum col channel state)fmt-tilde-s14816,203207
(defun fmt-var (s alist i maximum)fmt-var4871,205626
(defun splat-atom (x print-base print-radix indent col channel state)splat-atom4883,206192
(defun splat (x print-base print-radix indent col channel state)splat4901,206923
(defun splat1 (x print-base print-radix indent col channel state)splat14914,207492
(defun number-of-digits (n print-base print-radix)number-of-digits4948,209230
(defun left-pad-with-blanks (n width col channel state)left-pad-with-blanks4966,209902
(defmacro maybe-newline (body)maybe-newline4986,210668
(defun evisc-tuple (print-level print-length alist hiding-cars)evisc-tuple5013,211913
(defun standard-evisc-tuplep (x)standard-evisc-tuplep5077,214794
(defun abbrev-evisc-tuple (state)abbrev-evisc-tuple5088,215101
(defmacro gag-mode ()gag-mode5104,215797
(defun default-evisc-tuple (state)default-evisc-tuple5118,216101
(defun term-evisc-tuple (flg state)term-evisc-tuple5126,216516
(defun gag-mode-evisc-tuple (state)gag-mode-evisc-tuple5155,217767
(defun ld-evisc-tuple (state)ld-evisc-tuple5163,218004
(deflabel eviscerate-hide-termseviscerate-hide-terms5189,219288
(defun-one-output print-infix (x termp width rpc col file eviscp)print-infix5207,219887
(defun fmt-ppr (x termp width rpc col channel state eviscp)fmt-ppr5247,221763
(defun fmt0* (str0 str1 str2 str3 lst alist col channel state evisc-tuple)fmt0*5264,222290
(defun fmt0&v (flg lst punct col channel state evisc-tuple)fmt0&v5303,224082
(defun spell-number (n cap col channel state evisc-tuple)spell-number5349,226068
(defun fmt-tilde-s (s col channel state)fmt-tilde-s5419,229572
(defun fmt0 (s alist i maximum col channel state evisc-tuple)fmt05469,231489
(defun tilde-*-&v-strings (flg lst punct)tilde-*-&v-strings5915,255272
(defun fmt1 (str alist col channel state evisc-tuple)fmt15960,257211
(defun fmt (str alist channel state evisc-tuple)fmt5984,258020
(defun fms (str alist channel state evisc-tuple)fms6423,277911
(defun fmt1! (str alist col channel state evisc-tuple)fmt1!6441,278389
(defun fmt! (str alist channel state evisc-tuple)fmt!6464,279226
(defun fms! (str alist channel state evisc-tuple)fms!6487,280039
(defmacro fmx (str &rest args)fmx6509,280816
(defun fmt-doc-example1 (lst i)fmt-doc-example16516,281081
(defun fmt-doc-example (x state)fmt-doc-example6524,281391
(defun fmt-abbrev1 (str alist col channel state suffix-msg)fmt-abbrev16545,282482
(defun fmt-abbrev (str alist col channel state suffix-msg)fmt-abbrev6563,283274
(defconst *fmt-ctx-spacers**fmt-ctx-spacers*6569,283470
(defun fmt-ctx (ctx col channel state)fmt-ctx6598,284015
(defun fmt-in-ctx (ctx col channel state)fmt-in-ctx6641,285686
(defun error-fms-channel (hardp ctx str alist channel state)error-fms-channel6657,286227
(defun error-fms (hardp ctx str alist state)error-fms6680,287182
(defvar *accumulated-warnings* nil)*accumulated-warnings*6694,287584
(defun push-warning-frame (state)push-warning-frame6696,287621
(defun absorb-frame (lst stk)absorb-frame6702,287758
(defun pop-warning-frame (accum-p state)pop-warning-frame6708,287880
(defun push-warning (summary state)push-warning6743,289402
(defun member-string-equal (str lst)member-string-equal6766,290305
(defabbrev flambda-applicationp (term)flambda-applicationp6772,290460
(defabbrev lambda-applicationp (term)lambda-applicationp6778,290560
(defabbrev flambdap (fn)flambdap6782,290656
(defabbrev lambda-formals (x) (cadr x))lambda-formals6788,290746
(defabbrev lambda-body (x) (caddr x))lambda-body6790,290787
(defabbrev make-lambda (args body)make-lambda6792,290826
(defabbrev make-let (bindings body)make-let6795,290890
(defun doubleton-list-p (x)doubleton-list-p6798,290956
(defmacro er-let* (alist body)er-let*6804,291143
(defmacro er-let*@par (alist body)er-let*@par6832,292165
(defmacro match (x pat)match6857,293108
(defmacro match! (x pat)match!6860,293170
(defun def-basic-type-sets1 (lst i)def-basic-type-sets16867,293398
(defmacro def-basic-type-sets (&rest lst)def-basic-type-sets6874,293691
(defun list-of-the-type-set (x)list-of-the-type-set6888,294159
(defmacro ts= (a b)ts=6894,294321
(defmacro ts-complement0 (x)ts-complement06900,294529
(defmacro ts-complementp (x)ts-complementp6903,294621
(defun ts-union0-fn (x)ts-union0-fn6906,294671
(defmacro ts-union0 (&rest x)ts-union06913,294884
(defmacro ts-intersection0 (&rest x)ts-intersection06917,294977
(defmacro ts-disjointp (&rest x)ts-disjointp6921,295087
(defmacro ts-intersectp (&rest x)ts-intersectp6924,295174
(defun ts-builder-case-listp (x)ts-builder-case-listp6931,295498
(defun ts-builder-macro1 (x case-lst seen)ts-builder-macro16964,296871
(defun ts-builder-macro (x case-lst)ts-builder-macro6984,297846
(defmacro ts-builder (&rest args)ts-builder6990,298055
(defabbrev strip-not (term)strip-not6996,298286
(defun record-maker-function-name (name)record-maker-function-name7217,306893
(defun record-changer-function-name (name)record-changer-function-name7227,307192
(defmacro make (&rest args)make7236,307429
(defmacro change (&rest args)change7246,307786
(defun make-record-car-cdrs1 (lst var)make-record-car-cdrs17254,308119
(defun make-record-car-cdrs (field-layout car-cdr-lst)make-record-car-cdrs7258,308253
(defun make-record-accessors (name field-lst car-cdrs cheap)make-record-accessors7267,308712
(defun symbol-name-tree-occur (sym sym-tree)symbol-name-tree-occur7291,309869
(defun some-symbol-name-tree-occur (syms sym-tree)some-symbol-name-tree-occur7307,310457
(defun make-record-changer-cons (fields field-layout x)make-record-changer-cons7312,310656
(defun make-record-changer-let-bindings (field-layout lst)make-record-changer-let-bindings7331,311402
(defun make-record-changer-let (name field-layout cheap rec lst)make-record-changer-let7353,312440
(defun make-record-changer (name field-layout cheap)make-record-changer7379,313636
(defun make-record-maker-cons (fields field-layout)make-record-maker-cons7390,313950
(defun make-record-maker-let (name field-layout cheap lst)make-record-maker-let7417,315144
(defun make-record-maker (name field-layout cheap)make-record-maker7430,315620
(defun make-record-field-lst (field-layout)make-record-field-lst7440,315896
(defun record-maker-recognizer-name (name)record-maker-recognizer-name7447,316180
(defun make-record-recognizer-body (field-layout)make-record-recognizer-body7457,316482
(defun make-record-recognizer (name field-layout cheap recog-name)make-record-recognizer7481,317235
(defun record-macros (name field-layout cheap recog-name)record-macros7490,317622
(defmacro defrec (name field-lst cheap &optional recog-name)defrec7512,318778
(defabbrev equalityp (term)equalityp7520,319073
(defabbrev inequalityp (term)inequalityp7531,319437
(defabbrev consityp (term)consityp7542,319799
(defun power-rep (n b)power-rep7551,320023
(defun decode-idate (n)decode-idate7557,320135
(defun pcd2 (n channel state)pcd27580,320901
(defun print-idate (n channel state)print-idate7587,321117
(defun print-current-idate (channel state)print-current-idate7615,322053
(defconst *window-descriptions**window-descriptions*7670,325108
(defun io?-nil-output (lst default-bindings)io?-nil-output7688,325704
(defmacro check-exact-free-vars (ctx vars form)check-exact-free-vars7695,325996
(defun formal-bindings (vars)formal-bindings7722,327125
(defrec io-recordio-record7734,327472
(defmacro io-record-forms (io-records)io-record-forms7745,327761
(defun push-io-record (io-marker form state)push-io-record7752,327918
(defun saved-output-token-p (token state)saved-output-token-p7760,328221
(defun io?-wormhole-bindings (i vars)io?-wormhole-bindings7765,328451
(defmacro io? (token commentp shape vars bodyio?7773,328756
(defmacro io?@par (token commentp &rest rst)io?@par7919,335538
(defmacro io?-prove (vars body &rest keyword-args)io?-prove7932,335977
(defmacro io?-gag (vars body &rest keyword-args)io?-gag7940,336156
(defun output-ignored-p (token state)output-ignored-p7945,336297
(defun error1 (ctx str alist state)error17950,336470
(defun error1@par (ctx str alist state)error1@par7991,337924
(defun error1-safe (ctx str alist state)error1-safe8003,338244
(defconst *uninhibited-warning-summaries**uninhibited-warning-summaries*8014,338515
(defun warning-off-p1 (summary wrld ld-skip-proofsp)warning-off-p18028,338920
(defun warning-off-p (summary state)warning-off-p8051,339854
(defrec state-varsstate-vars8054,339954
(defmacro default-state-varsdefault-state-vars8064,340202
(defun warning1-body (ctx summary str alist state)warning1-body8118,342620
(defmacro warning1-form (commentp)warning1-form8134,343130
(defun warning1 (ctx summary str alist state)warning18168,344258
(defmacro warning$ (&rest args)warning$8175,344461
(defmacro warning-disabled-p (summary)warning-disabled-p8203,345597
(defmacro observation1-body (commentp)observation1-body8215,345980
(defun observation1 (ctx str alist abbrev-p state)observation18240,347143
(defun observation1-cw (ctx str alist abbrev-p)observation1-cw8248,347348
(defmacro observation (&rest args)observation8251,347422
(defmacro observation-cw (&rest args)observation-cw8339,351083
(defun skip-when-logic (str state)skip-when-logic8369,352178
(defun chk-inhibit-output-lst (lst ctx state)chk-inhibit-output-lst8377,352427
(defconst *ld-special-error**ld-special-error*8410,354024
(defun chk-ld-skip-proofsp (val ctx state)chk-ld-skip-proofsp8414,354138
(defun set-ld-skip-proofsp (val state)set-ld-skip-proofsp8424,354469
(defmacro set-ld-skip-proofs (val state)set-ld-skip-proofs8432,354688
(defun set-write-acl2x (val state)set-write-acl2x8441,354983
(defconst *check-sum-exclusive-maximum* 268435399*check-sum-exclusive-maximum*8663,367226
(defconst *check-length-exclusive-maximum* 2097143*check-length-exclusive-maximum*8667,367377
(defconst *-check-sum-exclusive-maximum* (- *check-sum-exclusive-maximum*))*-check-sum-exclusive-maximum*8675,367649
(defconst *1-check-length-exclusive-maximum**1-check-length-exclusive-maximum*8677,367726
(defun ascii-code! (x)ascii-code!8680,367813
(defun check-sum1 (sum len channel state)check-sum18689,367959
(defun check-sum (channel state)check-sum8715,369313
(defun check-sum-inc (n state)check-sum-inc8781,372871
(defun check-sum-natural (n state)check-sum-natural8812,374348
(defun check-sum-string1 (str i len state)check-sum-string18819,374640
(defun check-sum-string2 (str i len state)check-sum-string28837,375394
(defun check-sum-string (str state)check-sum-string8859,376283
(defun check-sum-obj1 (obj state)check-sum-obj18865,376532
(defun old-check-sum-obj (obj state)old-check-sum-obj8906,378431
(defun plus-mod-m31 (u v)plus-mod-m318977,382276
(defun double-mod-m31 (x)double-mod-m319011,383797
(defun times-expt-2-16-mod-m31 (x)times-expt-2-16-mod-m319026,384299
(defun times-mod-m31 (u v)times-mod-m319072,386299
(defun fchecksum-natural-aux (n ans)fchecksum-natural-aux9142,389306
(defun fchecksum-natural (n)fchecksum-natural9193,391281
(defun fchecksum-string1 (str i len ans)fchecksum-string19198,391411
(defun fchecksum-string2 (str i len ans)fchecksum-string29256,393830
(defun fchecksum-string (str)fchecksum-string9300,395590
(defvar *fchecksum-symbol-memo**fchecksum-symbol-memo*9325,396569
(defun fchecksum-atom (x)fchecksum-atom9328,396609
(defun fchecksum-obj (x)fchecksum-obj9400,399815
(defun check-sum-obj (obj)check-sum-obj9435,401340
(defun read-file-iterate (channel acc state)read-file-iterate9570,405988
(defun read-file (name state)read-file9577,406210
(defun formals (fn w)formals9587,406576
(defun arity (fn w)arity9600,407082
(defun stobjs-out (fn w)stobjs-out9606,407306
(deflabel user-defined-functions-tableuser-defined-functions-table9623,407850
(defconst *user-defined-functions-table-keys**user-defined-functions-table-keys*9701,411168
(defrec def-bodydef-body9718,411817
(defun latest-body (fncall hyp concl)latest-body9732,412156
(defun def-body (fn wrld)def-body9738,412297
(defun body (fn normalp w)body9741,412387
(defun symbol-class (sym wrld)symbol-class9769,413921
(defmacro fdefun-mode (fn wrld)fdefun-mode9822,416811
(defmacro programp (fn wrld)programp9830,416977
(defmacro logicalp (fn wrld)logicalp9833,417050
(defun program-termp (term wrld)program-termp9838,417148
(defun program-term-listp (lst wrld)program-term-listp9847,417493
(defdoc common-lispcommon-lisp9853,417659
(deflabel defun-mode-caveatdefun-mode-caveat9890,419631
(deflabel generalized-booleansgeneralized-booleans9988,424257
(defun defun-mode (name wrld)defun-mode10094,428096
(defun get-stobj-recognizer (stobj wrld)get-stobj-recognizer10244,435187
(defun stobj-recognizer-terms (known-stobjs wrld)stobj-recognizer-terms10255,435624
(defun mcons-term-smart (fn args)mcons-term-smart10265,436050
(defun optimize-stobj-recognizers1 (known-stobjs recog-terms term)optimize-stobj-recognizers110278,436378
(defun optimize-stobj-recognizers1-lst (known-stobjs recog-terms lst)optimize-stobj-recognizers1-lst10322,438275
(defun optimize-stobj-recognizers (known-stobjs term wrld)optimize-stobj-recognizers10330,438627
(defun guard (fn stobj-optp w)guard10355,439761
(defdoc extra-infoextra-info10418,442527
(defdoc guard-debugguard-debug10426,442771
(deflabel guard-quick-referenceguard-quick-reference10520,447292
(deflabel guard-introductionguard-introduction10596,450158
(deflabel guards-and-evaluationguards-and-evaluation10644,452542
(deflabel guards-for-specificationguards-for-specification11018,469430
(deflabel guard-miscellanyguard-miscellany11075,471793
(deflabel guard-evaluation-examples-scriptguard-evaluation-examples-script11153,476189
(deflabel guard-evaluation-examples-logguard-evaluation-examples-log11316,481671
(deflabel guard-evaluation-tableguard-evaluation-table12043,501463
(defun guard-lst (fns stobj-optp w)guard-lst12157,507491
(defmacro equivalence-relationp (fn w)equivalence-relationp12162,507657
(defun >=-len (x n)>=-len12187,508654
(defun all->=-len (lst n)all->=-len12195,508822
(defun strip-cadrs (x)strip-cadrs12202,509011
(defun strip-cddrs (x)strip-cddrs12209,509211
(defun global-set-lst (alist wrld)global-set-lst12214,509355
(defmacro cons-term1-body-mv2 ()cons-term1-body-mv212221,509612
(defun cons-term1-mv2 (fn args form)cons-term1-mv212231,509951
(defun sublis-var1 (alist form)sublis-var112238,510140
(defun sublis-var1-lst (alist l)sublis-var1-lst12258,511006
(defun sublis-var (alist form)sublis-var12273,511613
(defun sublis-var-lst (alist l)sublis-var-lst12299,512689
(defun subcor-var1 (vars terms var)subcor-var112308,513013
(defun subcor-var (vars terms form)subcor-var12319,513414
(defun subcor-var-lst (vars terms forms)subcor-var-lst12335,514093
(defun car-cdr-nest1 (term ad-lst n)car-cdr-nest112349,514625
(defun car-cdr-nest (term)car-cdr-nest12363,515133
(defun collect-non-trivial-bindings (vars vals)collect-non-trivial-bindings12386,515838
(defun untranslate-and (p q iff-flg)untranslate-and12393,516132
(defun untranslate-or (p q)untranslate-or12409,516572
(defun case-length (key term)case-length12419,516829
(defun cond-length (term)cond-length12453,518174
(defconst *untranslate-boolean-primitives**untranslate-boolean-primitives*12461,518408
(defun right-associated-args (fn term)right-associated-args12464,518464
(defun dumb-negate-lit (term)dumb-negate-lit12478,518976
(defun dumb-negate-lit-lst (lst)dumb-negate-lit-lst12495,519541
(defun term-stobjs-out-alist (vars args alist wrld)term-stobjs-out-alist12502,519717
(defun term-stobjs-out (term alist wrld)term-stobjs-out12511,520014
(defun accessor-root (n term wrld)accessor-root12554,521622
(defvar *load-compiled-stack* nil)*load-compiled-stack*12591,523466
(defun observe-raw-mode-setting (v state)observe-raw-mode-setting12594,523519
(defmacro progn! (&rest r)progn!12675,527630
(defmacro progn! (&rest r)progn!12804,533688
(defun ld-redefinition-action (state)ld-redefinition-action12844,535708
(deflabel redefining-programsredefining-programs13013,545338
(defun chk-ld-redefinition-action (val ctx state)chk-ld-redefinition-action13142,552031
(defun set-ld-redefinition-action (val state)set-ld-redefinition-action13150,552372
(defmacro redef nilredef13157,552584
(defmacro redef! nilredef!13176,553167
(defmacro redef+ nilredef+13195,553751
(defmacro redef- nilredef-13243,555476
(defun chk-current-package (val ctx state)chk-current-package13277,556495
(defun set-current-package (val state)set-current-package13282,556702
(defun standard-oi (state)standard-oi13293,556977
(defun read-standard-oi (state)read-standard-oi13319,558196
(defun chk-standard-oi (val ctx state)chk-standard-oi13332,558684
(defun set-standard-oi (val state)set-standard-oi13345,559058
(defun standard-co (state)standard-co13351,559250
(defun chk-standard-co (val ctx state)chk-standard-co13373,560196
(defun set-standard-co (val state)set-standard-co13380,560398
(defun proofs-co (state)proofs-co13387,560566
(defun chk-proofs-co (val ctx state)chk-proofs-co13405,561193
(defun set-proofs-co (val state)set-proofs-co13412,561391
(deflabel promptprompt13419,561551
(defun ld-prompt (state)ld-prompt13440,562440
(defun chk-ld-prompt (val ctx state)chk-ld-prompt13483,564518
(defun set-ld-prompt (val state)set-ld-prompt13494,564934
(defun ld-keyword-aliases (state)ld-keyword-aliases13501,565094
(defun ld-keyword-aliasesp (key val wrld)ld-keyword-aliasesp13581,568829
(defmacro add-ld-keyword-alias! (key val)add-ld-keyword-alias!13608,569712
(defmacro add-ld-keyword-alias! (key val)add-ld-keyword-alias!13615,569957
(defmacro add-ld-keyword-alias (key val)add-ld-keyword-alias13619,570036
(defmacro set-ld-keyword-aliases! (alist)set-ld-keyword-aliases!13623,570141
(defmacro set-ld-keyword-aliases! (alist)set-ld-keyword-aliases!13630,570395
(defmacro set-ld-keyword-aliases (alist &optional state)set-ld-keyword-aliases13634,570472
(defun ld-missing-input-ok (state)ld-missing-input-ok13642,570730
(defun msgp (x)msgp13664,571669
(defun chk-ld-missing-input-ok (val ctx state)chk-ld-missing-input-ok13670,571791
(defun set-ld-missing-input-ok (val state)set-ld-missing-input-ok13677,572043
(defun ld-pre-eval-filter (state)ld-pre-eval-filter13684,572243
(defun new-namep (name wrld)new-namep13714,573685
(defun chk-ld-pre-eval-filter (val ctx state)chk-ld-pre-eval-filter13807,577481
(defun set-ld-pre-eval-filter (val state)set-ld-pre-eval-filter13817,577895
(defun ld-pre-eval-print (state)ld-pre-eval-print13824,578091
(defun chk-ld-pre-eval-print (val ctx state)chk-ld-pre-eval-print13860,579960
(defun set-ld-pre-eval-print (val state)set-ld-pre-eval-print13865,580139
(defun ld-post-eval-print (state)ld-post-eval-print13872,580331
(defun chk-ld-post-eval-print (val ctx state)chk-ld-post-eval-print13934,583964
(defun set-ld-post-eval-print (val state)set-ld-post-eval-print13939,584159
(defun ld-error-triples (state)ld-error-triples13946,584355
(defun chk-ld-error-triples (val ctx state)chk-ld-error-triples13971,585517
(defun set-ld-error-triples (val state)set-ld-error-triples13976,585687
(defun ld-error-action (state)ld-error-action13983,585875
(defun chk-ld-error-action (val ctx state)chk-ld-error-action14098,592162
(defun set-ld-error-action (val state)set-ld-error-action14103,592358
(defun ld-query-control-alist (state)ld-query-control-alist14110,592542
(defun ld-query-control-alistp (val)ld-query-control-alistp14168,595785
(defun cdr-assoc-query-id (id alist)cdr-assoc-query-id14182,596275
(defun chk-ld-query-control-alist (val ctx state)chk-ld-query-control-alist14187,596436
(defun set-ld-query-control-alist (val state)set-ld-query-control-alist14193,596616
(defun ld-verbose (state)ld-verbose14200,596828
(defun chk-ld-verbose (val ctx state)chk-ld-verbose14231,598267
(defun set-ld-verbose (val state)set-ld-verbose14240,598544
(defconst *nqthm-to-acl2-primitives**nqthm-to-acl2-primitives*14247,598708
(defconst *nqthm-to-acl2-commands**nqthm-to-acl2-commands*14315,600676
(defun nqthm-to-acl2-fn (name state)nqthm-to-acl2-fn14407,604376
(defmacro nqthm-to-acl2 (x)nqthm-to-acl214526,608911
(defun allocate-fixnum-range (fixnum-lo fixnum-hi)allocate-fixnum-range14734,616969
(defmacro allegro-allocate-slowly (&key (free-bytes-new-other '1024)allegro-allocate-slowly14793,619795
(defun allegro-allocate-slowly-fn (free-bytes-new-otherallegro-allocate-slowly-fn14802,620354
(defmacro clear-pstk ()clear-pstk14839,621971
(defconst *pstk-vars**pstk-vars*14846,622151
(defun pstk-bindings-and-args (args vars)pstk-bindings-and-args14861,622374
(defmacro pstk (form)pstk14893,623455
(defun pstack-fn (allp state)pstack-fn14941,625291
(defmacro pstack (&optional allp)pstack14964,626150
(defun verbose-pstack (flg-or-list)verbose-pstack15033,628589
(defun pop-inhibit-output-lst-stack (state)pop-inhibit-output-lst-stack15066,629838
(defun push-inhibit-output-lst-stack (state)push-inhibit-output-lst-stack15076,630269
(defun set-gc-threshold$-fn (new-threshold verbose-p)set-gc-threshold$-fn15082,630514
(defmacro set-gc-threshold$ (new-threshold &optional (verbose-p 't))set-gc-threshold$15150,633472

parallel.lisp,4019
(defdoc deflockdeflock49,1910
(defdoc compiling-acl2pcompiling-acl2p133,5099
(defdoc parallelparallel172,6442
(defdoc parallelism-buildparallelism-build182,6596
(defun set-parallel-execution-fn (val ctx state)set-parallel-execution-fn190,6749
(defmacro set-parallel-execution (value)set-parallel-execution231,8769
(defdoc parallel-executionparallel-execution291,11345
(defun waterfall-printing-value-for-parallelism-value (value)waterfall-printing-value-for-parallelism-value301,11627
(defdoc unsupported-waterfall-parallelism-featuresunsupported-waterfall-parallelism-features335,13125
(defdoc unsupported-parallelism-featuresunsupported-parallelism-features492,21395
(defdoc waterfall-printingwaterfall-printing534,23391
(defdoc waterfall-parallelismwaterfall-parallelism542,23565
(defun print-set-waterfall-parallelism-notice (val print-val state)print-set-waterfall-parallelism-notice550,23738
(defun check-for-no-override-hints (ctx state)check-for-no-override-hints586,25276
(defun set-waterfall-parallelism-fn (val ctx state)set-waterfall-parallelism-fn616,26726
(defmacro set-waterfall-parallelism1 (val)set-waterfall-parallelism1706,31141
(defmacro save-memo-table ()save-memo-table735,32355
(defun clear-memo-table-events (alist acc)clear-memo-table-events743,32539
(defmacro clear-memo-table ()clear-memo-table751,32808
(defmacro save-and-clear-memoization-settings ()save-and-clear-memoization-settings759,33029
(defun set-memo-table-events (alist acc)set-memo-table-events785,33703
(defmacro restore-memoization-settings ()restore-memoization-settings793,33979
(defmacro set-waterfall-parallelism (val)set-waterfall-parallelism819,34577
(defdoc waterfall-parallelism-for-book-certificationwaterfall-parallelism-for-book-certification970,41910
(defun set-waterfall-printing-fn (val ctx state)set-waterfall-printing-fn1001,43191
(defmacro set-waterfall-printing (val)set-waterfall-printing1023,44114
(defun set-waterfall-parallelism-hacks-enabled-guard (wrld)set-waterfall-parallelism-hacks-enabled-guard1099,47512
(defmacro set-waterfall-parallelism-hacks-enabled (val)set-waterfall-parallelism-hacks-enabled1110,47976
(defmacro set-waterfall-parallelism-hacks-enabled! (val)set-waterfall-parallelism-hacks-enabled!1148,49563
(defdoc parallelism-at-the-top-levelparallelism-at-the-top-level1168,50190
(defdoc parallelism-tutorialparallelism-tutorial1223,52539
(defdoc granularitygranularity1507,63922
(defdoc parallelism-performanceparallelism-performance1615,68363
(defdoc early-terminationearly-termination1652,70135
(defdoc parallel-pushing-of-subgoals-for-inductionparallel-pushing-of-subgoals-for-induction1702,72336
(defun caar-is-declarep (x)caar-is-declarep1744,74768
(defun declare-granularity-p (x)declare-granularity-p1753,74979
(defun check-and-parse-for-granularity-form (x)check-and-parse-for-granularity-form1766,75357
(defmacro pargs (&rest forms)pargs1803,77045
(defmacro plet (&rest forms)plet1858,79471
(defun binary-pand (x y)binary-pand1908,81361
(defmacro pand (&rest forms)pand1916,81509
(defun binary-por (x y)binary-por2010,85305
(defmacro por (&rest forms)por2018,85461
(defun or-list (x)or-list2083,87981
(defun and-list (x)and-list2091,88136
(defun cpu-core-count (state)cpu-core-count2098,88283
(defmacro spec-mv-let (bindings computation body)spec-mv-let2324,98021
(defdoc error-triples-and-parallelismerror-triples-and-parallelism2448,103112
(defdoc with-output-lockwith-output-lock2498,105651
(defdoc acl2p-key-checkpointsacl2p-key-checkpoints2600,108604
(defun set-total-parallelism-work-limit-fn (val state)set-total-parallelism-work-limit-fn2715,113681
(defmacro set-total-parallelism-work-limit (val)set-total-parallelism-work-limit2720,113889
(defun set-total-parallelism-work-limit-error-fn (val state)set-total-parallelism-work-limit-error-fn2776,116331
(defmacro set-total-parallelism-work-limit-error (val)set-total-parallelism-work-limit-error2781,116543

translate.lisp,19625
(deflabel syntaxsyntax23,881
(deflabel termterm41,1351
(defun termp (x w)termp228,11066
(defun term-listp (x w)term-listp254,11935
(defun computed-hint-tuple-listp (x wrld)computed-hint-tuple-listp261,12065
(defun macro-args (x w)macro-args281,12620
(defconst *macro-expansion-ctx* "macro expansion")*macro-expansion-ctx*384,15627
(defun error-trace-suggestion (two-leading-spaces)error-trace-suggestion386,15679
(defun ignored-attachment-msg (ignored-attachment)ignored-attachment-msg397,16030
(defdoc ignored-attachmentignored-attachment405,16439
(defun ev-fncall-null-body-er-msg (ignored-attachment fn args)ev-fncall-null-body-er-msg518,20496
(defun ev-fncall-null-body-er (ignored-attachment fn args latches)ev-fncall-null-body-er539,21266
(defun ev-fncall-creator-er-msg (fn)ev-fncall-creator-er-msg544,21420
(defun unknown-pkg-error-msg (fn pkg-name)unknown-pkg-error-msg556,22021
(defun illegal-msg ()illegal-msg562,22208
(defun program-only-er-msg (fn args safe-mode)program-only-er-msg566,22299
(defconst *safe-mode-guard-er-addendum**safe-mode-guard-er-addendum*578,22906
(defun find-first-non-nil (lst)find-first-non-nil583,23150
(defun latch-stobjs1 (stobjs-out vals latches)latch-stobjs1590,23348
(defun latch-stobjs (stobjs-out vals latches)latch-stobjs643,25893
(defvar *raw-guard-warningp*)*raw-guard-warningp*668,27122
(defun actual-stobjs-out1 (stobjs-in args user-stobj-alist)actual-stobjs-out1670,27153
(defun apply-symbol-alist (alist lst acc)apply-symbol-alist686,27960
(defun apply-inverse-symbol-alist (alist lst acc)apply-inverse-symbol-alist700,28583
(defun actual-stobjs-out (fn args wrld user-stobj-alist)actual-stobjs-out715,29120
(defun raw-ev-fncall (fn args latches w user-stobj-alistraw-ev-fncall726,29600
(defun translated-acl2-unwind-protectp4 (term)translated-acl2-unwind-protectp4822,34182
(defun translated-acl2-unwind-protectp (term)translated-acl2-unwind-protectp897,37781
(defun stobjp (x known-stobjs w)stobjp908,38185
(defun acl2-system-namep (name wrld)acl2-system-namep1254,53562
(defparameter *ev-shortcut-okp**ev-shortcut-okp*1327,55827
(defun w-of-any-state (st)w-of-any-state1342,56491
(defun untranslate-preprocess-fn (wrld)untranslate-preprocess-fn1355,57054
(defmacro untranslate* (term iff-flg wrld)untranslate*1361,57319
(defmacro raw-guard-warningp-binding ()raw-guard-warningp-binding1377,57972
(defun untouchable-fn-p (fn w)untouchable-fn-p1405,59492
(defun save-ev-fncall-guard-er (fn guard stobjs-in args)save-ev-fncall-guard-er1409,59659
(defrec attachmentattachment1418,59967
(defrec attachment-componentattachment-component1425,60085
(defun attachment-record-pairs (records acc)attachment-record-pairs1432,60202
(defun all-attachments (wrld)all-attachments1440,60438
(defun gc-off1 (guard-checking-on)gc-off11444,60567
(defun gc-off (state)gc-off1448,60662
(defun return-last-lookup (sym wrld)return-last-lookup1465,61157
(defun make-let-or-let* (bindings body)make-let-or-let*1480,61630
(defmacro untranslate*-lst (lst iff-flg wrld)untranslate*-lst1494,62106
(defun apply-user-stobj-alist-or-kwote (user-stobj-alist lst acc)apply-user-stobj-alist-or-kwote1505,62400
(defun ev-fncall-rec-logical (fn args w user-stobj-alist big-n safe-mode gc-offev-fncall-rec-logical1544,64230
(defun ev-fncall-rec (fn args w user-stobj-alist big-n safe-mode gc-off latchesev-fncall-rec1869,77452
(defun ev-rec-return-last (fn arg2 arg3 alist w user-stobj-alist big-nev-rec-return-last1916,79319
(defun ev-rec (form alist w user-stobj-alist big-n safe-mode gc-off latchesev-rec2016,84242
(defun ev-rec-lst (lst alist w user-stobj-alist big-n safe-mode gc-off latchesev-rec-lst2202,93566
(defun ev-rec-acl2-unwind-protect (form alist w user-stobj-alist big-nev-rec-acl2-unwind-protect2235,95036
(defun ev-fncall-w (fn args w user-stobj-alist safe-mode gc-offev-fncall-w2456,105118
(defun ev-fncall-guard-er-msg (fn guard stobjs-in args w user-stobj-alist extra)ev-fncall-guard-er-msg2524,107694
(defun ev-fncall-guard-er (fn args w user-stobj-alist latches extra)ev-fncall-guard-er2580,110120
(defun ev-fncall-msg (val wrld user-stobj-alist)ev-fncall-msg2591,110521
(defun untranslate1 (term iff-flg untrans-tbl preprocess-fn wrld)untranslate12642,112353
(defun untranslate-cons1 (term untrans-tbl preprocess-fn wrld)untranslate-cons12871,124505
(defun untranslate-cons (term untrans-tbl preprocess-fn wrld)untranslate-cons2891,125507
(defun untranslate-if (term iff-flg untrans-tbl preprocess-fn wrld)untranslate-if2902,125952
(defun untranslate-into-case-clauses (key term iff-flg untrans-tbl preprocess-fnuntranslate-into-case-clauses2921,126915
(defun untranslate-into-cond-clauses (term iff-flg untrans-tbl preprocess-fnuntranslate-into-cond-clauses2963,129236
(defun untranslate1-lst (lst iff-flg untrans-tbl preprocess-fn wrld)untranslate1-lst2978,129977
(defun ev-fncall (fn args state latches hard-error-returns-nilp aok)ev-fncall2989,130410
(defun ev (form alist state latches hard-error-returns-nilp aok)ev3002,130989
(defun ev-lst (lst alist state latches hard-error-returns-nilp aok)ev-lst3036,132293
(defun untranslate (term iff-flg wrld)untranslate3054,133033
(defun untranslate-lst (lst iff-flg wrld)untranslate-lst3081,134112
(defun ev-w (form alist w user-stobj-alist safe-mode gc-offev-w3119,135670
(defun ev-w-lst (lst alist w user-stobj-alist safe-mode gc-offev-w-lst3180,138215
(defun silent-error (state)silent-error3306,144400
(defmacro cmp-to-error-triple (form)cmp-to-error-triple3309,144449
(defmacro cmp-to-error-triple@par (form)cmp-to-error-triple@par3325,145007
(defmacro cmp-to-error-double (form)cmp-to-error-double3341,145590
(defmacro cmp-and-value-to-error-quadruple (form)cmp-and-value-to-error-quadruple3357,146221
(defmacro cmp-and-value-to-error-quadruple@par (form)cmp-and-value-to-error-quadruple@par3379,147135
(defun er-cmp-fn (ctx msg)er-cmp-fn3399,147968
(defmacro er-cmp (ctx str &rest args)er-cmp3407,148148
(defmacro value-cmp (x)value-cmp3414,148333
(defun er-progn-fn-cmp (lst)er-progn-fn-cmp3417,148374
(defmacro er-progn-cmp (&rest lst)er-progn-cmp3439,149332
(defmacro er-let*-cmp (alist body)er-let*-cmp3444,149477
(defun warning1-cw (ctx summary str alist wrld state-vars)warning1-cw3469,150434
(defmacro warning$-cw1 (&rest args)warning$-cw13476,150638
(defmacro warning$-cw (ctx &rest args)warning$-cw3501,151460
(defun chk-length-and-keys (actuals form wrld)chk-length-and-keys3514,152006
(defun bind-macro-args-keys1 (args actuals allow-flg alist form wrldbind-macro-args-keys13534,152854
(defun bind-macro-args-keys (args actuals alist form wrld state-vars)bind-macro-args-keys3593,155712
(defun bind-macro-args-after-rest (args actuals alist form wrld state-vars)bind-macro-args-after-rest3611,156429
(defun bind-macro-args-optional (args actuals alist form wrld state-vars)bind-macro-args-optional3621,156826
(defun bind-macro-args1 (args actuals alist form wrld state-vars)bind-macro-args13656,158336
(defun bind-macro-args (args form wrld state-vars)bind-macro-args3682,159465
(defun macroexpand1-cmp (x ctx wrld state-vars)macroexpand1-cmp3690,159815
(defun macroexpand1 (x ctx state)macroexpand13749,162403
(defun chk-declare (form ctx)chk-declare3753,162562
(defun collect-dcls (l ctx)collect-dcls3773,163517
(defun acceptable-dcls-alist (state-vars)acceptable-dcls-alist3784,163898
(defconst *documentation-strings-permitted**documentation-strings-permitted*3813,165111
(defconst *dcl-explanation-alist**dcl-explanation-alist*3819,165262
(defun tilde-*-conjunction-phrase1 (syms alist)tilde-*-conjunction-phrase13829,165784
(defun tilde-*-conjunction-phrase (syms alist)tilde-*-conjunction-phrase3840,166262
(defun collect-non-legal-variableps (lst)collect-non-legal-variableps3857,166915
(defun optimize-alistp (lst)optimize-alistp3863,167143
(defun chk-dcl-lst (l vars binder ctx wrld state-vars)chk-dcl-lst3876,167564
(defun number-of-strings (l)number-of-strings4054,177039
(defun remove-strings (l)remove-strings4060,177202
(defun get-string (l)get-string4066,177368
(defun collect-declarations-cmp (lst vars binder ctx wrld state-vars)collect-declarations-cmp4071,177492
(defun collect-declarations (lst vars binder state ctx)collect-declarations4111,179484
(defun listify (l)listify4116,179744
(defun translate-declaration-to-guard-var-lst (x var-lst wrld)translate-declaration-to-guard-var-lst4120,179842
(defun translate-dcl-lst (edcls wrld)translate-dcl-lst4134,180505
(defun dcl-guardian (term-lst)dcl-guardian4148,181101
(defun ignore-vars (dcls)ignore-vars4181,182638
(defun ignorable-vars (dcls)ignorable-vars4187,182821
(defun mv-nth-list (var i maximum)mv-nth-list4193,183016
(defabbrev translate-bind (x val bindings)translate-bind4198,183193
(defun translate-deref (x bindings)translate-deref4204,183328
(defun translate-unbound (x bindings)translate-unbound4220,183894
(defun listlis (l1 l2)listlis4228,184098
(defun find-first-var (term)find-first-var4238,184305
(defun find-first-var-lst (lst)find-first-var-lst4246,184543
(defun find-first-fnsymb (term)find-first-fnsymb4254,184714
(defun find-first-fnsymb-lst (lst)find-first-fnsymb-lst4262,184988
(defun find-pkg-witness (term)find-pkg-witness4268,185149
(defmacro trans-er (&rest args)trans-er4287,185865
(defmacro trans-er+ (form ctx str &rest args)trans-er+4303,186600
(defmacro trans-er+? (cform x ctx str &rest args)trans-er+?4322,187370
(defmacro trans-value (x &optional (bindings 'bindings))trans-value4338,188024
(defmacro trans-er-let* (alist body)trans-er-let*4344,188171
(defun hide-ignored-actuals (ignore-vars bound-vars value-forms)hide-ignored-actuals4367,189008
(defun augment-ignore-vars (bound-vars value-forms acc)augment-ignore-vars4393,189977
(defun compute-stobj-flags (lst known-stobjs w)compute-stobj-flags4501,195792
(defun prettyify-stobj-flags (lst)prettyify-stobj-flags4514,196285
(defun unprettyify-stobj-flags (lst)unprettyify-stobj-flags4523,196571
(defun prettyify-stobjs-out (stobjs-out)prettyify-stobjs-out4528,196745
(defun defstobj-supporterp (name wrld)defstobj-supporterp4537,197041
(defun stobj-creatorp (name wrld)stobj-creatorp4553,197754
(defun defstobj-fnname (root key1 key2 renaming-alist)defstobj-fnname4565,198172
(defun parse-with-local-stobj (x)parse-with-local-stobj4624,200785
(defun ffnnamep (fn term)ffnnamep4644,201292
(defun ffnnamep-lst (fn l)ffnnamep-lst4658,201745
(defconst *synp-trans-err-string**synp-trans-err-string*4668,201966
(defconst *ttag-fns-and-macros**ttag-fns-and-macros*4674,202314
(defun unknown-binding-msg (stobjs-bound str1 str2 str3)unknown-binding-msg4696,202993
(defconst *oneify-primitives**oneify-primitives*4714,204135
(defconst *macros-for-nonexpansion-in-raw-lisp**macros-for-nonexpansion-in-raw-lisp*4760,205908
(defun chk-no-duplicate-defuns-cmp (lst ctx)chk-no-duplicate-defuns-cmp4820,208214
(defun chk-no-duplicate-defuns (lst ctx state)chk-no-duplicate-defuns4830,208634
(defun chk-state-ok-msg (wrld)chk-state-ok-msg4833,208745
(defun chk-state-ok (ctx wrld state)chk-state-ok4848,209371
(defun chk-arglist-msg (args chk-state wrld)chk-arglist-msg4853,209517
(defun msg-to-cmp (ctx msg)msg-to-cmp4870,210251
(defun chk-arglist-cmp (args chk-state ctx wrld)chk-arglist-cmp4879,210492
(defun@par chk-arglist (args chk-state ctx wrld state)chk-arglist4882,210600
(defun logical-name-type (name wrld quietp)logical-name-type4887,210786
(defun chk-all-but-new-name-cmp (name ctx new-type w)chk-all-but-new-name-cmp4912,211785
(defun chk-all-but-new-name (name ctx new-type w state)chk-all-but-new-name4943,213042
(defun chk-defuns-tuples-cmp (lst local-p ctx wrld state-vars)chk-defuns-tuples-cmp4946,213171
(defun chk-defuns-tuples (lst local-p ctx wrld state)chk-defuns-tuples4990,215049
(defun non-trivial-encapsulate-ee-entries (embedded-event-lst)non-trivial-encapsulate-ee-entries4994,215243
(defconst *ec-call-bad-ops**ec-call-bad-ops*5003,215651
(defmacro return-last-call (fn &rest args)return-last-call5013,216044
(defmacro prog2$-call (x y)prog2$-call5016,216131
(defun name-dropper (lst)name-dropper5019,216205
(defun first-assoc-eq (keys alist)first-assoc-eq5035,216920
(defun context-for-encapsulate-pass-2 (wrld in-local-flg)context-for-encapsulate-pass-25043,217185
(defconst *brr-globals**brr-globals*5073,218600
(defun unknown-binding-msg-er (x ctx stobjs-bound str1 str2 str3)unknown-binding-msg-er5079,218694
(defun congruent-stobj-rep (name wrld)congruent-stobj-rep5099,219680
(defun congruent-stobjsp (st1 st2 wrld)congruent-stobjsp5105,219881
(defun stobjs-in-out1 (stobjs-in args known-stobjs wrld alist new-stobjs-in)stobjs-in-out15109,219998
(defun stobjs-in-matchp (stobjs-in args)stobjs-in-matchp5134,221158
(defun stobjs-in-out (fn args stobjs-out known-stobjs wrld)stobjs-in-out5142,221421
(defun non-trivial-stobj-binding (stobj-flags bindings)non-trivial-stobj-binding5180,223211
(defun formalized-varlistp (varlist formal-lst)formalized-varlistp5192,223799
(defun throw-nonexec-error-p1 (targ1 targ2 name formals)throw-nonexec-error-p15204,224280
(defun throw-nonexec-error-p (body name formals)throw-nonexec-error-p5224,225064
(defun chk-flet-declarations (names decls declare-form ctx)chk-flet-declarations5239,225779
(defun chk-flet-declare-form (names declare-form ctx)chk-flet-declare-form5265,227103
(defun chk-flet-declare-form-list (names declare-form-list ctx)chk-flet-declare-form-list5280,227704
(defun translate-stobj-type-to-guard (x var wrld)translate-stobj-type-to-guard5287,228003
(defun get-stobj-creator (stobj wrld)get-stobj-creator5322,229788
(defun stobj-updater-guess-from-accessor (accessor)stobj-updater-guess-from-accessor5360,231498
(defun parse-stobj-let1 (bindings producer-vars bound-vars actuals stobjparse-stobj-let15381,232254
(defun illegal-stobj-let-msg (msg form)illegal-stobj-let-msg5473,236376
(defun parse-stobj-let (x)parse-stobj-let5477,236500
(defun pairlis-x1 (x1 lst)pairlis-x15571,240606
(defun pairlis-x2 (lst x2)pairlis-x25579,240794
(defun no-duplicatesp-checks-for-stobj-let-actuals/alist (alist)no-duplicatesp-checks-for-stobj-let-actuals/alist5587,240986
(defun no-duplicatesp-checks-for-stobj-let-actuals (exprs alist)no-duplicatesp-checks-for-stobj-let-actuals5601,241683
(defun stobj-let-fn (x)stobj-let-fn5625,242710
(defun the-live-var (name)the-live-var5659,244208
(defun the-live-var-bindings (stobj-names)the-live-var-bindings5678,245059
(defun the-maybe-live-var-bindings (stobj-names)the-maybe-live-var-bindings5684,245301
(defun stobj-let-fn-raw (x)stobj-let-fn-raw5694,245705
(defun stobj-field-accessor-p (fn stobj wrld)stobj-field-accessor-p5780,249171
(defun chk-stobj-let/bindings (stobj bound-vars actuals wrld)chk-stobj-let/bindings5802,249758
(defun chk-stobj-let/updaters1 (updaters accessors lst)chk-stobj-let/updaters15840,251657
(defun chk-stobj-let/updaters (updaters corresp-accessor-fns stobj wrld)chk-stobj-let/updaters5870,253133
(defun chk-stobj-let (bound-vars actuals stobj updaters corresp-accessor-fnschk-stobj-let5877,253393
(defun all-nils-or-x (x lst)all-nils-or-x5899,254287
(defun stobj-field-fn-of-stobj-type-p (fn wrld)stobj-field-fn-of-stobj-type-p5908,254549
(defun stobj-recognizer-p (fn wrld)stobj-recognizer-p5920,255105
(defmacro trans-or (form1 condition form2 extra-msg)trans-or5929,255380
(defun translate11-flet-alist (form fives stobjs-out bindings known-stobjstranslate11-flet-alist5960,256723
(defun translate11-flet-alist1 (form five stobjs-out bindings known-stobjstranslate11-flet-alist15974,257381
(defun translate11-flet (x stobjs-out bindings known-stobjs flet-alisttranslate11-flet6176,266964
(defun translate-stobj-calls (calls len bindings known-stobjs flet-alisttranslate-stobj-calls6244,269904
(defun translate11-let (x tbody0 targs stobjs-out bindings known-stobjstranslate11-let6280,271725
(defun translate11-let* (x tbody targs stobjs-out bindings known-stobjstranslate11-let*6486,282473
(defun translate11-mv-let (x tbody0 stobjs-out bindings known-stobjstranslate11-mv-let6511,283698
(defun translate11-wormhole-eval (x y z bindings flet-alist ctx wrldtranslate11-wormhole-eval6731,294808
(defun translate11-call (form fn args stobjs-out stobjs-out2 bindingstranslate11-call6826,299142
(defun translate11 (x stobjs-out bindings known-stobjs flet-alisttranslate117012,308534
(defun translate11-lst (lst stobjs-out bindings known-stobjstranslate11-lst8196,367641
(defun translate1-cmp (x stobjs-out bindings known-stobjs ctx w state-vars)translate1-cmp8318,373932
(defun@par translate1 (x stobjs-out bindings known-stobjs ctx w state)translate18383,377021
(defun collect-programs (names wrld)collect-programs8388,377238
(defun all-fnnames1 (flg x acc)all-fnnames18420,378393
(defmacro all-fnnames (term)all-fnnames8439,379085
(defmacro all-fnnames-lst (lst)all-fnnames-lst8442,379148
(defun translate-cmp (x stobjs-out logic-modep known-stobjs ctx w state-vars)translate-cmp8445,379211
(defun@par translate (x stobjs-out logic-modep known-stobjs ctx w state)translate8470,380368
(defun translatable-p (form stobjs-out bindings known-stobjs ctx wrld)translatable-p8501,381836
(defmacro chk-translatable (form shape)chk-translatable8508,382127
(defun replaced-stobj (name)replaced-stobj8534,383381
(defun replace-stobjs1 (stobjs-out val)replace-stobjs18540,383550
(defun replace-stobjs (stobjs-out val)replace-stobjs8548,383846
(defun non-stobjps (vars known-stobjs w)non-stobjps8589,385739
(defun user-stobjsp (stobjs-out)user-stobjsp8596,385990
(defun put-assoc-eq-alist (alist1 alist2)put-assoc-eq-alist8603,386194
(defun-one-output chk-user-stobj-alist (stobjs alist acc ctx)chk-user-stobj-alist8637,387915
(defun user-stobj-alist-safe (ctx stobjs state)user-stobj-alist-safe8662,389006
(defun ev-for-trans-eval (trans vars stobjs-out ctx state aok)ev-for-trans-eval8671,389280
(defun ev-w-for-trans-eval (trans vars stobjs-out ctx state aok)ev-w-for-trans-eval8723,391570
(defun trans-eval (form ctx state aok)trans-eval8759,392847
(defun simple-translate-and-eval (x alist ok-stobj-names msg ctx wrld statesimple-translate-and-eval8805,394717
(defun error-fms-cw (hardp ctx str alist)error-fms-cw8899,399341
(defmacro error-fms@par (&rest args)error-fms@par8916,400022
(defun simple-translate-and-eval-cmp (x alist ok-stobj-names msg ctx wrld statesimple-translate-and-eval-cmp8919,400086
(defun simple-translate-and-eval-error-double (x alist ok-stobj-names msg ctxsimple-translate-and-eval-error-double8981,403056
(defun simple-translate-and-eval@par (x alist ok-stobj-names msg ctx wrld statesimple-translate-and-eval@par9010,404340
(defun tilde-*-alist-phrase1 (alist evisc-tuple level)tilde-*-alist-phrase19026,405172
(defun tilde-*-alist-phrase (alist evisc-tuple level)tilde-*-alist-phrase9032,405438
(defun set-temp-touchable-fns (x state)set-temp-touchable-fns9044,405733
(defun set-temp-touchable-vars (x state)set-temp-touchable-vars9061,406428
(defun clear-temp-touchable-fns (state)clear-temp-touchable-fns9078,407126
(defun clear-temp-touchable-vars (state)clear-temp-touchable-vars9081,407215
(defun mapcar$ (fn l state)mapcar$9097,407980
(defun mapdo (fn l state)mapdo9119,408884
(defun always (fn l state)always9132,409343
(defun thereis (fn l state)thereis9146,409760

type-set-a.lisp,3571
(defconst *ts-non-negative-integer* (ts-union0 *ts-zero**ts-non-negative-integer*124,5901
(defconst *ts-non-positive-integer* (ts-union0 *ts-zero**ts-non-positive-integer*127,6030
(defconst *ts-integer* (ts-union0 *ts-positive-integer**ts-integer*130,6159
(defconst *ts-rational* (ts-union0 *ts-integer**ts-rational*134,6318
(defconst *ts-real* (ts-union0 *ts-integer**ts-real*141,6570
(defconst *ts-complex* (ts-union0 *ts-complex-rational**ts-complex*151,6940
(defconst *ts-acl2-number**ts-acl2-number*160,7355
(defconst *ts-rational-acl2-number* (ts-union0 *ts-rational**ts-rational-acl2-number*166,7525
(defconst *ts-non-rational-acl2-number* (ts-union0 *ts-positive-non-ratio**ts-non-rational-acl2-number*170,7683
(defconst *ts-negative-rational* (ts-union0 *ts-negative-integer**ts-negative-rational*174,7913
(defconst *ts-positive-rational* (ts-union0 *ts-positive-integer**ts-positive-rational*177,8046
(defconst *ts-non-positive-rational* (ts-union0 *ts-zero**ts-non-positive-rational*180,8179
(defconst *ts-non-negative-rational* (ts-union0 *ts-zero**ts-non-negative-rational*183,8311
(defconst *ts-ratio* (ts-union0 *ts-positive-ratio**ts-ratio*186,8443
(defconst *ts-non-ratio* (ts-union0 *ts-positive-non-ratio**ts-non-ratio*197,8772
(defconst *ts-negative-real* (ts-union0 *ts-negative-integer**ts-negative-real*200,8895
(defconst *ts-positive-real* (ts-union0 *ts-positive-integer**ts-positive-real*204,9084
(defconst *ts-non-positive-real* (ts-union0 *ts-zero**ts-non-positive-real*208,9273
(defconst *ts-non-negative-real* (ts-union0 *ts-zero**ts-non-negative-real*211,9393
(defconst *ts-cons* (ts-union0 *ts-proper-cons**ts-cons*215,9515
(defconst *ts-boolean* (ts-union0 *ts-nil* *ts-t*))*ts-boolean*218,9616
(defconst *ts-true-list* (ts-union0 *ts-nil* *ts-proper-cons*))*ts-true-list*220,9669
(defconst *ts-non-nil* (ts-complement0 *ts-nil*))*ts-non-nil*222,9734
(defconst *ts-symbol* (ts-union0 *ts-nil**ts-symbol*224,9785
(defconst *ts-true-list-or-string* (ts-union0 *ts-true-list* *ts-string*))*ts-true-list-or-string*228,9929
(defconst *ts-empty* 0)*ts-empty*230,10005
(defconst *ts-unknown* -1)*ts-unknown*232,10030
(defun one-bit-type-setp (ts)one-bit-type-setp240,10392
(defconst *code-type-set-alist**code-type-set-alist*278,12045
(defun logior-lst (lst ans)logior-lst362,15691
(defun logand-lst (lst ans)logand-lst368,15821
(defun ts-complement-fn (x)ts-complement-fn376,15970
(defun ts-union-fn (x)ts-union-fn382,16117
(defun ts-intersection-fn (x)ts-intersection-fn392,16425
(defun eval-type-set (x)eval-type-set402,16744
(defun eval-type-set-lst (x)eval-type-set-lst423,17560
(defmacro ts-complement (x)ts-complement436,17878
(defmacro ts-intersection (&rest x)ts-intersection439,17952
(defmacro ts-union (&rest x)ts-union442,18036
(defmacro ts-subsetp (ts1 ts2)ts-subsetp445,18106
(defun type-set-binary-+-alist-entry (ts1 ts2)type-set-binary-+-alist-entry460,18553
(defun type-set-binary-+-alist1 (i j lst)type-set-binary-+-alist1592,25217
(defun type-set-binary-+-alist (i j lst)type-set-binary-+-alist601,25623
(defun type-set-binary-*-alist-entry (ts1 ts2)type-set-binary-*-alist-entry609,25887
(defun type-set-binary-*-alist1 (i j lst)type-set-binary-*-alist1742,32974
(defun type-set-binary-*-alist (i j lst)type-set-binary-*-alist752,33433
(defun type-set-<-alist-entry (ts1 ts2)type-set-<-alist-entry760,33697
(defun type-set-<-alist1 (i j lst)type-set-<-alist1844,37738
(defun type-set-<-alist (i j lst)type-set-<-alist854,38117

linear-a.lisp,9228
(defabbrev ts-acl2-numberp (ts)ts-acl2-numberp35,1338
(defabbrev ts-rationalp (ts)ts-rationalp38,1407
(defabbrev ts-real/rationalp (ts)ts-real/rationalp41,1470
(defabbrev ts-integerp (ts)ts-integerp47,1618
(defun all-quoteps (lst)all-quoteps50,1679
(defun dumb-occur (x y)dumb-occur57,1826
(defun dumb-occur-lst (x lst)dumb-occur-lst68,2143
(defrec history-entryhistory-entry84,2675
(defun pt-occur (n pt)pt-occur193,9106
(defun pt-intersectp (pt1 pt2)pt-intersectp201,9304
(deflabel ttreettree293,13656
(defun tag-tree-occur (tag val ttree)tag-tree-occur320,14942
(defun remove-tag-from-tag-tree (tag ttree)remove-tag-from-tag-tree328,15118
(defun remove-tag-from-tag-tree! (tag ttree)remove-tag-from-tag-tree!339,15416
(defmacro extend-tag-tree (tag vals ttree)extend-tag-tree354,15866
(defun add-to-tag-tree (tag val ttree)add-to-tag-tree362,16043
(defun add-to-tag-tree! (tag val ttree)add-to-tag-tree!381,16622
(defconst *fake-rune-for-anonymous-enabled-rule**fake-rune-for-anonymous-enabled-rule*404,17454
(defabbrev push-lemma (rune ttree)push-lemma407,17552
(defun delete-assoc-eq-assoc-eq-1 (alist1 alist2)delete-assoc-eq-assoc-eq-1431,18808
(defun delete-assoc-eq-assoc-eq (alist1 alist2)delete-assoc-eq-assoc-eq444,19349
(defun cons-tag-trees1 (ttree1 ttree2 ttree3)cons-tag-trees1450,19526
(defun cons-tag-trees (ttree1 ttree2)cons-tag-trees471,20536
(defmacro tagged-objects (tag ttree)tagged-objects493,21399
(defmacro tagged-objectsp (tag ttree)tagged-objectsp501,21558
(defun tagged-object (tag ttree)tagged-object511,21865
(deflock *ttree-lock*)*ttree-lock*537,23163
(defun@par accumulate-ttree-and-step-limit-into-state (ttree step-limit state)accumulate-ttree-and-step-limit-into-state539,23187
(defun pts-to-ttree-lst (pts)pts-to-ttree-lst582,25156
(defun marry-parents (parents1 parents2)marry-parents594,25695
(defun collect-parents1 (pt ans)collect-parents1606,26088
(defun collect-parents0 (pts ans)collect-parents0615,26319
(defun collect-parents (ttree)collect-parents622,26479
(defun ignore-polyp (parents pt)ignore-polyp631,26844
(defun to-be-ignoredp1 (pts pt)to-be-ignoredp1646,27492
(defun to-be-ignoredp (ttree pt)to-be-ignoredp651,27644
(defrec assumnote (cl-id rune . target) t)assumnote679,28813
(defrec assumptionassumption694,29746
(defrec fc-derivationfc-derivation755,33360
(defun contains-assumptionp (ttree)contains-assumptionp767,33715
(defun contains-assumptionp-fc-derivations (lst)contains-assumptionp-fc-derivations777,34074
(defun remove-assumption-entries-from-type-alist (type-alist)remove-assumption-entries-from-type-alist783,34296
(defun force-assumption1force-assumption1802,35012
(defun dumb-occur-in-type-alist (var type-alist)dumb-occur-in-type-alist832,36345
(defun all-dumb-occur-in-type-alist (vars type-alist)all-dumb-occur-in-type-alist841,36541
(defun force-assumptionforce-assumption848,36755
(defun tag-tree-occur-assumption-nil-1 (lst)tag-tree-occur-assumption-nil-1945,42074
(defun tag-tree-occur-assumption-nil (ttree)tag-tree-occur-assumption-nil952,42290
(defun assumption-free-ttreep (ttree)assumption-free-ttreep959,42535
(defconst *impossible-assumption**impossible-assumption*979,43381
(deflabel linear-arithmeticlinear-arithmetic1483,63384
(defmacro fn-count-evg-max-val ()fn-count-evg-max-val1590,68216
(defmacro fn-count-evg-max-val-neg ()fn-count-evg-max-val-neg1598,68462
(defmacro fn-count-evg-max-calls ()fn-count-evg-max-calls1601,68532
(defun min-fixnum (x y)min-fixnum1612,68842
(defun fn-count-evg-rec (evg acc calls)fn-count-evg-rec1620,69075
(defmacro fn-count-evg (evg)fn-count-evg1693,72318
(defun var-fn-count-1 (flg x var-count-acc fn-count-acc p-fn-count-accvar-fn-count-11696,72380
(defmacro var-fn-count (term invisible-fns-table)var-fn-count1798,77743
(defmacro var-or-fn-count-< (var-count1 var-count2 fn-count1 fn-count2var-or-fn-count-<1804,77896
(defun term-order1 (term1 term2 invisible-fns-table)term-order11831,79223
(defun arith-term-order (term1 term2)arith-term-order1902,83620
(defrec polypoly1916,83960
(defabbrev first-var (p) (caar (access poly p :alist)))first-var2046,90529
(defabbrev first-coefficient (p) (cdar (access poly p :alist)))first-coefficient2048,90586
(defun good-coefficient (c)good-coefficient2071,91644
(defun good-pot-varp (x)good-pot-varp2074,91694
(defun good-polyp (p)good-polyp2084,92074
(defun logical-< (x y)logical-<2094,92468
(defun logical-<= (x y)logical-<=2107,92880
(defun evaluate-ground-poly (p)evaluate-ground-poly2117,93206
(defun impossible-polyp (p)impossible-polyp2126,93475
(defun true-polyp (p)true-polyp2130,93584
(defun silly-polyp (poly)silly-polyp2134,93678
(defun impossible-poly (ttree)impossible-poly2141,93884
(defun base-poly0 (ttree parents relation rational-poly-p derived-from-not-equalityp)base-poly02151,94121
(defun base-poly (ttree relation rational-poly-p derived-from-not-equalityp)base-poly2164,94486
(defun poly-alist-equal (alist1 alist2)poly-alist-equal2177,94859
(defun poly-equal (poly1 poly2)poly-equal2191,95256
(defun poly-weakerp (poly1 poly2 parents-check)poly-weakerp2202,95635
(defun poly-member (p lst)poly-member2235,97018
(defun new-and-ugly-linear-varsp (lst flag term)new-and-ugly-linear-varsp2251,97675
(defun filter-polys (lst ans)filter-polys2277,98693
(defun add-linear-variable1 (n var alist)add-linear-variable12304,99663
(defun zero-factor-p (term)zero-factor-p2328,100653
(defun get-coefficient (term acc)get-coefficient2349,101487
(defun add-linear-variable (term side p)add-linear-variable2363,102025
(defun dumb-eval-yields-quotep (term)dumb-eval-yields-quotep2385,102699
(defun dumb-eval (term)dumb-eval2407,103504
(defun add-linear-term (term side p)add-linear-term2436,104490
(defun add-linear-terms-fn (rst)add-linear-terms-fn2506,107054
(defmacro add-linear-terms (&rest rst)add-linear-terms2520,107505
(defun normalize-poly1 (coeff alist)normalize-poly12538,108056
(defun normalize-poly (p)normalize-poly2545,108249
(defun normalize-poly-lst (poly-lst)normalize-poly-lst2561,108652
(defrec linear-pot ((loop-stopper-value . negatives) . (var . positives)) t)linear-pot2574,108927
(defun modify-linear-pot (pot pos neg)modify-linear-pot2583,109431
(defconst *max-linear-pot-loop-stopper-value* 3)*max-linear-pot-loop-stopper-value*2657,112361
(defun loop-stopper-value-of-var (var pot-lst)loop-stopper-value-of-var2659,112411
(defun set-loop-stopper-values (new-vars new-pot-lst term value)set-loop-stopper-values2670,112800
(defun var-in-pot-lst-p (var pot-lst)var-in-pot-lst-p2702,114447
(defun bounds-poly-with-var (poly-lst pt bounds-poly)bounds-poly-with-var2712,114712
(defun bounds-polys-with-var (var pot-lst pt)bounds-polys-with-var2738,115940
(defun polys-with-var1 (var pot-lst)polys-with-var12763,116869
(defun polys-with-var (var pot-lst)polys-with-var2770,117172
(defun polys-with-pots (polys pot-lst ans)polys-with-pots2782,117608
(defun new-vars-in-pot-lst (new-pot-lst old-pot-lst include-variableps)new-vars-in-pot-lst2795,118024
(defun changed-pot-vars (new-pot-lst old-pot-lst to-be-ignored-lst)changed-pot-vars2843,120598
(defun infect-polys (lst ttree parents)infect-polys2869,121822
(defun infect-first-n-polys (lst n ttree parents)infect-first-n-polys2884,122406
(defun infect-new-polys (new-pot-lst old-pot-lst ttree)infect-new-polys2899,123017
(defun fcomplementary-multiplep1 (alist1 alist2)fcomplementary-multiplep12970,126312
(defun fcomplementary-multiplep (poly1 poly2)fcomplementary-multiplep2983,126796
(defun already-used-by-find-equational-polyp-lst (poly1 lst)already-used-by-find-equational-polyp-lst2998,127451
(defun already-used-by-find-equational-polyp (poly1 hist)already-used-by-find-equational-polyp3003,127667
(defun cons-term-binary-+-constant (x term)cons-term-binary-+-constant3032,129115
(defun cons-term-unary-- (term)cons-term-unary--3041,129412
(defun cons-term-binary-*-constant (x term)cons-term-binary-*-constant3047,129646
(defun find-equational-poly-rhs1 (alist)find-equational-poly-rhs13058,130009
(defun find-equational-poly-rhs (poly1)find-equational-poly-rhs3072,130511
(defun find-equational-poly3 (poly1 poly2 hist)find-equational-poly33103,131546
(defun find-equational-poly2 (poly1 negatives hist)find-equational-poly23131,132829
(defun find-equational-poly1 (positives negatives hist)find-equational-poly13151,133529
(defun find-equational-poly (pot hist)find-equational-poly3171,134277
(defun get-coeff-for-cancel1 (alist1 alist2)get-coeff-for-cancel13208,135903
(defun cancel2 (alist coeff)cancel23232,136711
(defun cancel1 (alist1 alist2 coeff)cancel13240,136914
(defun cancel (p1 p2)cancel3266,137953
(defun cancel-poly-against-all-polys (p polys pt ans)cancel-poly-against-all-polys3336,141335
(defun add-poly (p pot-lst to-do-next pt nonlinearp)add-poly3427,145440
(defun prune-poly-lst (poly-lst ans)prune-poly-lst3554,150929
(defun add-polys1 (lst pot-lst new-lst pt nonlinearp max-roundsadd-polys13562,151192
(defun add-polys0 (lst pot-lst pt nonlinearp max-rounds)add-polys03607,153282

type-set-b.lisp,22537
(defconst *number-of-numeric-type-set-bits**number-of-numeric-type-set-bits*26,995
(defconst *type-set-binary-+-table-list**type-set-binary-+-table-list*30,1099
(defconst *type-set-binary-+-table**type-set-binary-+-table*39,1468
(defconst *type-set-binary-*-table-list**type-set-binary-*-table-list*43,1589
(defconst *type-set-binary-*-table**type-set-binary-*-table*52,1958
(defconst *type-set-<-table-list**type-set-<-table-list*60,2240
(defconst *type-set-<-table**type-set-<-table*75,2691
(defun assoc-equal-cdr (x alist)assoc-equal-cdr89,3292
(defun runep (x wrld)runep97,3517
(defmacro base-symbol (rune)base-symbol228,10269
(defmacro strip-base-symbols (runes)strip-base-symbols242,10835
(deflabel executable-counterpartexecutable-counterpart245,10898
(deflabel worldworld324,14702
(deflabel runerune433,21437
(deflabel rule-namesrule-names580,28785
(defun fnume (rune wrld)fnume595,29023
(defun frunic-mapping-pair (rune wrld)frunic-mapping-pair611,29800
(defun fn-rune-nume (fn nflg xflg wrld)fn-rune-nume619,30054
(defun definition-runes (fns xflg wrld)definition-runes635,30839
(defun get-next-nume (lst)get-next-nume640,31021
(defun deref-macro-name (macro-name macro-aliases)deref-macro-name676,32855
(defun deref-macro-name-lst (macro-name-lst macro-aliases)deref-macro-name-lst682,33014
(defconst *abbrev-rune-alist**abbrev-rune-alist*687,33260
(defun translate-abbrev-rune (x macro-aliases)translate-abbrev-rune693,33403
(defun rule-name-designatorp (x macro-aliases wrld)rule-name-designatorp703,33758
(defun theoryp1 (lst macro-aliases wrld)theoryp1748,36001
(defun theoryp (lst wrld)theoryp754,36205
(defun theoryp!1 (lst fail-flg macro-aliases wrld)theoryp!1762,36478
(defun theoryp! (lst wrld)theoryp!784,37507
(defun runic-theoryp1 (prev-nume lst wrld)runic-theoryp1789,37627
(defun runic-theoryp (lst wrld)runic-theoryp804,38175
(defun find-mapping-pairs-tail1 (rune mapping-pairs)find-mapping-pairs-tail1880,42450
(defun find-mapping-pairs-tail (rune mapping-pairs wrld)find-mapping-pairs-tail895,43118
(defun augment-runic-theory1 (lst mapping-pairs wrld ans)augment-runic-theory1912,43941
(defun augment-runic-theory (lst wrld)augment-runic-theory934,44999
(defconst *bad-runic-designator-string**bad-runic-designator-string*959,46319
(defun convert-theory-to-unordered-mapping-pairs1 (lst macro-aliases wrld ans)convert-theory-to-unordered-mapping-pairs1965,46679
(defun convert-theory-to-unordered-mapping-pairs (lst wrld)convert-theory-to-unordered-mapping-pairs1025,49030
(defun duplicitous-cons-car (x y)duplicitous-cons-car1043,49847
(defun duplicitous-revappend-car (lst ans)duplicitous-revappend-car1052,50099
(defun duplicitous-merge-car (parity lst1 lst2 ans)duplicitous-merge-car1060,50362
(defun duplicitous-sort-car (parity lst)duplicitous-sort-car1094,52187
(defun augment-theory (lst wrld)augment-theory1115,53192
(defmacro assert$-runic-theoryp (runic-theory-expr wrld)assert$-runic-theoryp1143,54581
(defun runic-theory (lst wrld)runic-theory1157,54899
(defrec enabled-structureenabled-structure1198,56839
(defun enabled-numep (nume ens)enabled-numep1282,61643
(defun enabled-arith-numep (nume ens)enabled-arith-numep1297,62147
(defun enabled-runep (rune ens wrld)enabled-runep1317,62997
(defmacro active-runep (rune)active-runep1325,63279
(defun enabled-xfnp (fn ens wrld)enabled-xfnp1360,64465
(defun sublis-var! (alist term ens wrld ttree)sublis-var!1381,65302
(defun sublis-var!-lst (alist lst ens wrld ttree)sublis-var!-lst1490,69492
(defun theory-warning-fns-aux (runes1 runes2 max-numetheory-warning-fns-aux1507,70081
(defun theory-warning-fns (ens1 ens2 w)theory-warning-fns1535,71298
(defun@par maybe-warn-about-theory (ens1 force-xnume-en1 imm-xnume-en1 ens2maybe-warn-about-theory1562,72904
(defrec theory-invariant-recordtheory-invariant-record1617,75301
(defun@par chk-theory-invariant1 (theory-expr ens invariant-alist errp-acc ctxchk-theory-invariant11621,75370
(defun@par chk-theory-invariant (theory-expr ens ctx state)chk-theory-invariant1709,79790
(defrec clause-idclause-id1735,80701
(defun pos-listp (l)pos-listp1748,81154
(defun all-digits-p (lst radix)all-digits-p1755,81315
(defun d-pos-listp (lst)d-pos-listp1764,81658
(defun clause-id-p (cl-id)clause-id-p1776,82100
(defconst *initial-clause-id**initial-clause-id*1791,82467
(defun chars-for-tilde-@-clause-id-phrase/periods (lst)chars-for-tilde-@-clause-id-phrase/periods1815,83611
(defun chars-for-tilde-@-clause-id-phrase/primes (n)chars-for-tilde-@-clause-id-phrase/primes1825,83958
(defun chars-for-tilde-@-clause-id-phrase (id)chars-for-tilde-@-clause-id-phrase1833,84237
(defun string-for-tilde-@-clause-id-phrase (id)string-for-tilde-@-clause-id-phrase1859,85552
(defun@par load-theory-into-enabled-structureload-theory-into-enabled-structure1867,85777
(defun initial-global-enabled-structure (root-string)initial-global-enabled-structure1955,90372
(defun recompress-global-enabled-structure (varname wrld)recompress-global-enabled-structure1984,91590
(defun recompress-stobj-accessor-arrays (stobj-names wrld)recompress-stobj-accessor-arrays2044,94494
(defconst *fake-rune-for-type-set**fake-rune-for-type-set*2100,97530
(defun puffert (ttree)puffert2105,97667
(defun immediate-forcep (fn ens)immediate-forcep2115,98079
(defmacro numeric-type-set (ts)numeric-type-set2123,98288
(defmacro rational-type-set (ts)rational-type-set2146,99235
(defmacro real-type-set (ts)real-type-set2167,100017
(defun type-set-binary-+ (term ts1 ts2 ttree ttree0)type-set-binary-+2188,100793
(defun type-set-binary-* (ts1 ts2 ttree ttree0)type-set-binary-*2230,102850
(defun type-set-not (ts ttree ttree0)type-set-not2246,103418
(defun type-set-<-1 (r arg2 commutedp type-alist)type-set-<-12254,103618
(defun type-set-< (arg1 arg2 ts1 ts2 type-alist ttree ttree0 pot-lst pt)type-set-<2371,108055
(defun type-set-unary-- (ts ttree ttree0)type-set-unary--2533,115792
(defun type-set-unary-/ (ts ttree ttree0)type-set-unary-/2556,116814
(defun type-set-numerator (ts ttree ttree0)type-set-numerator2575,117712
(defun type-set-realpart (ts ttree ttree0)type-set-realpart2590,118396
(defun type-set-imagpart (ts ttree ttree0)type-set-imagpart2601,118789
(defun type-set-complex (ts1 ts2 ttree ttree0)type-set-complex2622,119568
(defun type-set-floor1 (ts ttree ttree0)type-set-floor12665,121386
(defun type-set-standard-part (ts ttree ttree0)type-set-standard-part2680,122063
(defun type-set-standardp (ts ttree ttree0)type-set-standardp2696,122731
(defrec recognizer-tuplerecognizer-tuple2712,123257
(defconst *initial-recognizer-alist**initial-recognizer-alist*2822,127951
(defun most-recent-enabled-recog-tuple (fn alist ens)most-recent-enabled-recog-tuple2928,131698
(defun type-set-recognizer (recog-tuple arg-ts ttree ttree0)type-set-recognizer2940,132209
(defun type-set-car (ts ttree ttree0)type-set-car2973,133765
(defun type-set-cdr (ts ttree ttree0)type-set-cdr2977,133902
(defun type-set-coerce (term ts1 ts2 ttree1 ttree2 ttree0)type-set-coerce2988,134256
(defun type-set-intern-in-package-of-symbol (ts1 ts2 ttree1 ttree2 ttree0)type-set-intern-in-package-of-symbol3010,135128
(defun type-set-length (ts ttree ttree0)type-set-length3017,135414
(defun type-set-cons (ts2 ttree ttree0)type-set-cons3028,135782
(defconst *singleton-type-sets**singleton-type-sets*3039,136135
(defun type-set-equal (ts1 ts2 ttree ttree0)type-set-equal3042,136204
(defun type-set-quote (evg)type-set-quote3055,136737
(defun type-set-char-code (ts ttree ttree0)type-set-char-code3092,138039
(defun fn-count-1 (flg x fn-count-acc p-fn-count-acc)fn-count-13102,138387
(defmacro fn-count (term)fn-count3140,140215
(defun term-order (term1 term2)term-order3143,140273
(defrec type-prescriptiontype-prescription3298,147920
(defun find-runed-type-prescription (rune lst)find-runed-type-prescription3341,149710
(defconst *expandable-boot-strap-non-rec-fns**expandable-boot-strap-non-rec-fns*3352,150037
(defun mv-atf (not-flg mbt mbf tta fta ttree1 ttree2)mv-atf3410,152883
(defun assume-true-false-error (type-alist x temp-temp)assume-true-false-error3448,154460
(defun non-cons-cdr (term)non-cons-cdr3457,154830
(defconst *one-way-unify1-implicit-fns**one-way-unify1-implicit-fns*3475,155630
(defun one-way-unify1 (pat term alist)one-way-unify13486,155794
(defun one-way-unify1-lst (pl tl alist)one-way-unify1-lst3719,167461
(defun one-way-unify1-equal1 (pat1 pat2 term1 term2 alist)one-way-unify1-equal13736,168121
(defun one-way-unify1-equal (pat1 pat2 term1 term2 alist)one-way-unify1-equal3760,169273
(defun one-way-unify (pat term)one-way-unify3768,169512
(defun canonical-representative (equiv term type-alist)canonical-representative3828,172431
(defun subst-type-alist1-check (old equiv type-alist)subst-type-alist1-check3874,174043
(defun nil-fn ()nil-fn3885,174424
(defconst *nil-fn-ts-entry**nil-fn-ts-entry*3893,174642
(defun subst-type-alist1 (new old equiv ttree type-alist acc)subst-type-alist13898,174772
(defun subst-type-alist (new old equiv ttree type-alist)subst-type-alist3966,177969
(defun infect-type-alist-entry (entry ttree)infect-type-alist-entry3981,178571
(defun infect-new-type-alist-entries2 (new-type-alist old-type-alist ttree)infect-new-type-alist-entries23989,178789
(defun infect-new-type-alist-entries1 (new-type-alist old-type-alist ttree n)infect-new-type-alist-entries14008,179587
(defun infect-new-type-alist-entries (new-type-alist old-type-alist ttree)infect-new-type-alist-entries4021,180131
(defun extend-type-alist-simple (term ts ttree type-alist)extend-type-alist-simple4040,181045
(defun extend-type-alist1 (equiv occursp1 occursp2 both-canonicalp arg1-canonextend-type-alist14059,181825
(defun extend-type-alist (term ts ttree type-alist wrld)extend-type-alist4137,185090
(defun zip-variable-type-alist (vars pairs)zip-variable-type-alist4188,187338
(defun assoc-equiv (fn arg1 arg2 alist)assoc-equiv4202,187949
(defun assoc-equiv+ (equiv arg1 arg2 type-alist)assoc-equiv+4221,188700
(defun assoc-type-alist (term type-alist wrld)assoc-type-alist4287,191679
(defun look-in-type-alist (term type-alist wrld)look-in-type-alist4304,192295
(defun member-char-stringp (chr str i)member-char-stringp4309,192451
(defun terminal-substringp1 (str1 str2 max1 max2)terminal-substringp14320,192836
(defun terminal-substringp (str1 str2 max1 max2)terminal-substringp4336,193472
(defun evg-occur (x y)evg-occur4346,193898
(defun occur (term1 term2)occur4415,196809
(defun occur-lst (term1 args2)occur-lst4427,197210
(defun pseudo-variantp (term1 term2)pseudo-variantp4452,198053
(defun pseudo-variantp-list (args1 args2)pseudo-variantp-list4487,199469
(defun worse-than-builtin (term1 term2)worse-than-builtin4749,207467
(defun worse-than-or-equal-builtin (term1 term2)worse-than-or-equal-builtin4787,209210
(defun basic-worse-than-lst1 (args1 args2)basic-worse-than-lst14819,210512
(defun basic-worse-than-lst2 (args1 args2)basic-worse-than-lst24838,211361
(defun basic-worse-than (term1 term2)basic-worse-than4854,212033
(defun some-subterm-worse-than-or-equal (term1 term2)some-subterm-worse-than-or-equal4904,214302
(defun some-subterm-worse-than-or-equal-lst (args term2)some-subterm-worse-than-or-equal-lst4924,215140
(defun worse-than-lst (args term2)worse-than-lst4935,215678
(defrec ancestorancestor4981,217082
(defmacro make-ancestor-binding-hyp (hyp unify-subst)make-ancestor-binding-hyp4995,217597
(defmacro ancestor-binding-hyp-p (anc)ancestor-binding-hyp-p5002,217770
(defmacro ancestor-binding-hyp/hyp (anc)ancestor-binding-hyp/hyp5006,217867
(defmacro ancestor-binding-hyp/unify-subst (anc)ancestor-binding-hyp/unify-subst5009,217941
(defun push-ancestor (lit tokens ancestors)push-ancestor5014,218081
(defun ancestor-listp (x)ancestor-listp5044,219448
(defun earlier-ancestor-biggerp (var-cnt fn-cnt p-fn-cnt tokens ancestors)earlier-ancestor-biggerp5072,220535
(defun equal-mod-commuting (x y wrld)equal-mod-commuting5102,222021
(defun ancestors-check1 (lit-atm lit var-cnt fn-cnt p-fn-cnt ancestors tokens)ancestors-check15130,223016
(defun ancestors-check-builtin (lit ancestors tokens)ancestors-check-builtin5271,230556
(defproxy ancestors-check (* * *) => (mv * *))ancestors-check5319,232590
(defun map-multiply-car (multiplicative-constant x)map-multiply-car5386,235037
(defun normalize-addend (addend)normalize-addend5392,235284
(defun insert-cdr-term-order (item list)insert-cdr-term-order5416,236243
(defun normalize-linear-sum-2 (term)normalize-linear-sum-25425,236501
(defun normalize-linear-sum-1 (additive-constant term)normalize-linear-sum-15437,236969
(defun normalize-linear-sum (term)normalize-linear-sum5487,239324
(defun normalize-linear-sum-p1 (stripped-term term-to-match)normalize-linear-sum-p15557,242134
(defun normalize-linear-sum-p (stripped-term term-to-match)normalize-linear-sum-p5566,242526
(defun type-set-finish-1 (additive-const multiplicative-const stripped-termtype-set-finish-15594,243758
(defun type-set-finish (x ts0 ttree0 ts1 ttree1 type-alist)type-set-finish5786,254215
(defun search-type-alist-rec (term alt-term typ type-alist unify-subst ttree)search-type-alist-rec5824,255889
(defun free-varsp (term alist)free-varsp5862,257639
(defun free-varsp-lst (args alist)free-varsp-lst5867,257805
(defun search-type-alist-with-rest (term typ type-alist unify-subst ttree wrld)search-type-alist-with-rest5874,257968
(defun search-type-alist (term typ type-alist unify-subst ttree wrld)search-type-alist5907,259517
(defun term-and-typ-to-lookup (hyp wrld)term-and-typ-to-lookup5956,261923
(defun lookup-hyp (hyp type-alist wrld unify-subst ttree)lookup-hyp5977,262832
(defun bind-free-vars-to-unbound-free-vars (vars alist)bind-free-vars-to-unbound-free-vars5987,263222
(defabbrev x-xrunep (xrune) ; extended xrunepx-xrunep6070,267627
(defabbrev hyp-xrune (n rune)hyp-xrune6074,267733
(defabbrev hyp-xrune-rune (xrune)hyp-xrune-rune6078,267830
(defabbrev conc-xrune (rune)conc-xrune6083,267963
(defabbrev conc-xrune-rune (xrune)conc-xrune-rune6087,268058
(defabbrev xrune-rune (xrune)xrune-rune6092,268192
(defabbrev rune= (rune1 rune2)rune=6099,268355
(defabbrev xrune= (xrune1 xrune2)xrune=6103,268464
(defun prettyify-xrune (xrune)prettyify-xrune6113,268825
(defrec accp-infoaccp-info6123,269164
(defrec accp-entryaccp-entry6156,270359
(defun merge-accumulated-persistence-aux (xrune entry alist)merge-accumulated-persistence-aux6226,273765
(defun merge-accumulated-persistence-rec (new-alist old-alist)merge-accumulated-persistence-rec6249,274867
(defun merge-accumulated-persistence (new-alist old-alist)merge-accumulated-persistence6258,275202
(defun add-accumulated-persistence-s (xrune delta-s delta-f alistadd-accumulated-persistence-s6368,279607
(defun add-accumulated-persistence-f (xrune delta-s delta-f alistadd-accumulated-persistence-f6395,280748
(defun accumulated-persistence-make-failures (alist)accumulated-persistence-make-failures6425,282011
(defun add-accumulated-persistence (xrune success-p delta-s delta-fadd-accumulated-persistence6437,282560
(defmacro accumulated-persistence (flg)accumulated-persistence6461,283659
(defmacro set-accumulated-persistence (flg)set-accumulated-persistence6862,304577
(defdoc accumulated-persistence-subtletiesaccumulated-persistence-subtleties6865,304657
(defun merge-car-> (l1 l2)merge-car->6995,309798
(defun merge-sort-car-> (l)merge-sort-car->7002,310023
(defconst *accp-major-separator**accp-major-separator*7007,310188
(defconst *accp-minor-separator**accp-minor-separator*7010,310265
(defun show-accumulated-persistence-phrase0 (entry key)show-accumulated-persistence-phrase07013,310342
(defun show-accumulated-persistence-phrase1 (key alist mergep acc)show-accumulated-persistence-phrase17041,311348
(defun show-accumulated-persistence-remove-useless (alist acc)show-accumulated-persistence-remove-useless7073,312710
(defun show-accumulated-persistence-phrase-key (key entry lastcdr)show-accumulated-persistence-phrase-key7083,313114
(defun show-accumulated-persistence-phrase2-merge (key alist last-key-info)show-accumulated-persistence-phrase2-merge7100,313827
(defun show-accumulated-persistence-phrase2-not-merge (key alist)show-accumulated-persistence-phrase2-not-merge7130,315051
(defun show-accumulated-persistence-phrase2 (key alist mergep)show-accumulated-persistence-phrase27139,315498
(defun split-xrune-alist (alist rune-alist hyp-xrune-alist conc-xrune-alist)split-xrune-alist7143,315711
(defun sort-xrune-alist-by-rune1 (rune-alist hyp-xrune-alist conc-xrune-alistsort-xrune-alist-by-rune17164,316730
(defun sort-xrune-alist-by-rune (alist display)sort-xrune-alist-by-rune7197,318336
(defun pop-accp-fn (info success-p)pop-accp-fn7215,319172
(defun pop-accp-fn-iterate (info n)pop-accp-fn-iterate7272,321700
(defun show-accumulated-persistence-phrase (key/display accp-info)show-accumulated-persistence-phrase7288,322374
(defmacro show-accumulated-persistence (&optional (sortkey ':frames)show-accumulated-persistence7360,325988
(defun push-accp (rune x-info)push-accp7410,328392
(defun pop-accp (success-p x-info)pop-accp7456,331054
(defmacro with-accumulated-persistence (rune vars success-p bodywith-accumulated-persistence7473,331815
(defun assume-true-false-<assume-true-false-<7523,334017
(defun mv-atf-2 (not-flg true-type-alist false-type-alistmv-atf-27729,342635
(defun binding-hyp-p (hyp alist wrld)binding-hyp-p7782,344760
(defmacro adjust-ignore-for-atf (not-flg ignore)adjust-ignore-for-atf7830,347138
(defun backchain-limit-reachedp1 (n ancestors)backchain-limit-reachedp17842,347537
(defun backchain-limit-reachedp (n ancestors)backchain-limit-reachedp7847,347704
(defun new-backchain-limit (new-offset old-limit ancestors)new-backchain-limit7858,348223
(defproxy oncep-tp (* *) => *)oncep-tp7885,349162
(defun oncep-tp-builtin (rune wrld)oncep-tp-builtin7887,349194
(defun type-set-rec (x force-flg dwp type-alist ancestors ens w ttreetype-set-rec7897,349387
(defun type-set-lst (x force-flg dwp type-alist ancestors ens wtype-set-lst8429,373922
(defun type-set-relieve-hyps-free (term typ rest-type-alisttype-set-relieve-hyps-free8450,374947
(defun type-set-relieve-hyps1 (hyp forcep rune target hyps backchain-limit-lsttype-set-relieve-hyps18493,377002
(defun type-set-relieve-hyps (rune target hyps backchain-limit-lsttype-set-relieve-hyps8649,382804
(defun extend-type-alist-with-bindings (alist force-flg dwp type-alistextend-type-alist-with-bindings8920,395576
(defun type-set-with-rule (tp term force-flg dwp type-alist ancestors ens wtype-set-with-rule8947,396757
(defun type-set-with-rule1 (alist vars force-flg dwp type-alist ancestors ens wtype-set-with-rule19036,400812
(defun type-set-with-rules (tp-lst term force-flg dwp type-alist ancestors enstype-set-with-rules9073,402863
(defun type-set-primitive (term force-flg dwp type-alist ancestors ens w ttree0type-set-primitive9126,405256
(defun assume-true-false-if (not-flg x xttree force-flg dwpassume-true-false-if9663,427822
(defun assume-true-false-rec (x xttree force-flg dwp type-alist ancestors ens wassume-true-false-rec9963,443098
(defun assume-true-false1 (not-flg x xttree force-flg dwp type-alist ancestorsassume-true-false111066,498228
(defun proper/improper-cons-ts-tuple (term ts ttree force-flg dwp type-alistproper/improper-cons-ts-tuple11124,500807
(defun extend-with-proper/improper-cons-ts-tupleextend-with-proper/improper-cons-ts-tuple11198,504314
(defun type-set (x force-flg dwp type-alist ens w ttree pot-lst pt)type-set11217,505133
(defun assume-true-false (x xttree force-flg dwp type-alist ens w pot-lst ptassume-true-false11372,512808
(defun ok-to-force-ens (ens)ok-to-force-ens11379,513124
(defun add-linear-assumption (target term type-alist ensadd-linear-assumption11388,513481
(defun return-type-alistreturn-type-alist11496,518354
(defun type-alist-equality-loop1 (type-alist top-level-type-alist ens w)type-alist-equality-loop111526,519511
(defun clean-up-alist (alist ans)clean-up-alist11617,523567
(defun duplicate-keysp (alist)duplicate-keysp11630,524132
(defun clean-type-alist (type-alist)clean-type-alist11643,524629
(defun type-alist-equality-loop-exit (type-alist)type-alist-equality-loop-exit11660,525391
(defconst *type-alist-equality-loop-max-depth* 10)*type-alist-equality-loop-max-depth*11666,525613
(defun type-alist-equality-loop (type-alist0 ens w n)type-alist-equality-loop11668,525665
(defun put-assoc-equal-ts (term ts ttree type-alist)put-assoc-equal-ts11699,527049
(defun reconsider-type-alist (type-alist xtype-alist force-flg ens w pot-lstreconsider-type-alist11711,527589
(defun type-alist-clause-finish1 (lits ttree-lst force-flg type-alist ens wrld)type-alist-clause-finish111773,530512
(defun type-alist-clause-finish (lits ttree-lst force-flg type-alist ens wrldtype-alist-clause-finish11809,532253
(defun type-alist-clause (cl ttree-lst force-flg type-alist ens wrldtype-alist-clause11941,539350
(defun known-whether-nil (x type-alist ens force-flg dwp wrld ttree)known-whether-nil12003,542946
(defun ts-booleanp (term ens wrld)ts-booleanp12035,544632
(defun weak-cons-occur (x y)weak-cons-occur12046,545119
(defun equal-x-cons-x-yp (lhs rhs)equal-x-cons-x-yp12060,545577
(defun not-ident (term1 term2 type-alist ens wrld)not-ident12135,548929
(defun first-if (args i)first-if12170,550568
(defun all-variablep (lst)all-variablep12184,551056
(defun normalize-with-type-set (term iff-flg type-alist ens wrld ttree)normalize-with-type-set12189,551191
(defun normalize (term iff-flg type-alist ens wrld ttree)normalize12221,552379
(defun normalize-lst (args iff-flg type-alist ens wrld ttree)normalize-lst12370,559473
(defun normalize-or-distribute-first-if (term iff-flg type-alist ens wrldnormalize-or-distribute-first-if12379,559937
(defun distribute-first-if (term iff-flg type-alist ens wrld ttree)distribute-first-if12397,560743
(defun decode-type-set1 (ts alist)decode-type-set112517,566224
(defun decode-type-set (ts)decode-type-set12527,566622
(defmacro dts (term type-alist)dts12545,567342
(defun ens (state)ens12562,567853
(defmacro git (sym prop)git12565,567923

linear-b.lisp,1003
(defun polys-from-type-set (term force-flag dwp type-alist ens wrld ttree)polys-from-type-set36,1154
(defun add-type-set-polys (var-lst new-pot-lst old-pot-lstadd-type-set-polys133,5323
(defun add-polynomial-inequalities (lst pot-lst pt nonlinearp type-alist ensadd-polynomial-inequalities176,7396
(defparameter *add-polys-counter**add-polys-counter*203,8547
(defun add-polys (lst pot-lst pt nonlinearp type-alist ens force-flg wrld)add-polys210,8702
(defun eval-ground-subexpressions (term ens wrld state ttree)eval-ground-subexpressions231,9291
(defun eval-ground-subexpressions-lst (lst ens wrld state ttree)eval-ground-subexpressions-lst326,12671
(defun poly-set (op poly1 poly2)poly-set341,13175
(defun linearize1 (term positivep type-alist ens force-flg wrld ttree state)linearize1423,17357
(defun linearize (term positivep type-alist ens force-flg wrld ttree state)linearize802,33926
(defun linearize-lst1linearize-lst1847,36093
(defun linearize-lstlinearize-lst877,37416

non-linear.lisp,2036
(defun cleanse-type-alist (type-alist pt)cleanse-type-alist29,1083
(defun var-with-divisionp (var)var-with-divisionp56,1948
(defun varify (x)varify87,3196
(defun varify! (x)varify!110,3790
(defun varify!-lst1 (lst acc)varify!-lst1119,4021
(defun varify!-lst (lst)varify!-lst124,4141
(defun invert-var (var)invert-var131,4311
(defun part-of1 (var1 var2)part-of1172,6125
(defun part-of (var1 var2)part-of203,7114
(defun product-already-triedp (var-list products-already-tried)product-already-triedp220,7633
(defun too-many-polysp (var-lst pot-lst counter)too-many-polysp234,8146
(defun expanded-new-vars-in-pot-lst2 (new-var vars-to-skip vars-to-return)expanded-new-vars-in-pot-lst2252,8721
(defun expanded-new-vars-in-pot-lst1 (new-pot-lst vars-to-skipexpanded-new-vars-in-pot-lst1285,10134
(defun expanded-new-vars-in-pot-lst (new-pot-lst old-pot-lst)expanded-new-vars-in-pot-lst331,12494
(defun extract-bounds (bounds-polys)extract-bounds355,13495
(defun good-bounds-in-pot (var pot-lst pt)good-bounds-in-pot397,15667
(defun inverse-polys (var inv-var pot-lst ttree pt)inverse-polys426,16721
(defun add-inverse-polys (varadd-inverse-polys762,33525
(defun add-polys-from-type-set (var pot-lst type-alistadd-polys-from-type-set805,35285
(defun length-of-shortest-polys-with-var (poly-lst pt n)length-of-shortest-polys-with-var841,36731
(defun shortest-polys-with-var1 (poly-lst pt n)shortest-polys-with-var1861,37649
(defun shortest-polys-with-var (var pot-lst pt)shortest-polys-with-var873,38158
(defun binary-*-leaves (term)binary-*-leaves905,39466
(defun binary-*-tree (leaves)binary-*-tree911,39624
(defun merge-arith-term-order (l1 l2)merge-arith-term-order929,40137
(defun insert-arith-term-order (item list)insert-arith-term-order936,40398
(defun sort-arith-term-order (list)sort-arith-term-order945,40654
(defun multiply-alist-and-const (alist const poly)multiply-alist-and-const952,40855
(defun collect-rational-poly-p-lst (poly-lst)collect-rational-poly-p-lst967,41543

tau.lisp,22407
(defun almost-lexorder-singletons (x y)almost-lexorder-singletons49,2456
(defun member-nil-neg-evgs (neg-evg-lst)member-nil-neg-evgs57,2733
(defun member-neg-evgs1 (evg neg-evg-lst)member-neg-evgs161,2844
(defun member-neg-evgs (x neg-evg-lst)member-neg-evgs71,3173
(defun insert-neg-evgs1 (evg x neg-evg-lst)insert-neg-evgs184,3633
(defun insert-neg-evgs (x neg-evg-lst)insert-neg-evgs96,4077
(defun merge-car-< (l1 l2)merge-car-<106,4456
(defun merge-sort-car-< (l)merge-sort-car-<113,4681
(defun merge-cadr-< (l1 l2)merge-cadr-<121,4921
(defun merge-sort-cadr-< (l)merge-sort-cadr-<128,5151
(defun strip-caddrs (x)strip-caddrs136,5398
(defun unprettyify/add-hyps-to-pairs (hyps lst)unprettyify/add-hyps-to-pairs148,5972
(defun flatten-ands-in-lit (term)flatten-ands-in-lit157,6311
(defun unprettyify (term)unprettyify170,6843
(defun reprettyify (hyps concl wrld)reprettyify219,9041
(defun remove-guard-holders1 (changedp0 term)remove-guard-holders1274,11766
(defun remove-guard-holders1-lst (lst)remove-guard-holders1-lst363,15730
(defun remove-guard-holders (term)remove-guard-holders374,16170
(defun remove-guard-holders-lst (lst)remove-guard-holders-lst384,16442
(defun remove-guard-holders1-lst-lst (lst)remove-guard-holders1-lst-lst393,16687
(defun remove-guard-holders-lst-lst (lst)remove-guard-holders-lst-lst403,17133
(defun convert-returned-vars-to-term-lst (term vars)convert-returned-vars-to-term-lst419,17665
(defun implicate (t1 t2)implicate424,17872
(defrec type-set-inverter-rule ((nume . ts) terms . rune) nil)type-set-inverter-rule436,18198
(defconst *initial-type-set-inverter-rules**initial-type-set-inverter-rules*464,19621
(defun convert-type-set-to-term-lst (ts rules ens lst ttree)convert-type-set-to-term-lst687,30092
(defun subst-var (new old form)subst-var726,31680
(defun subst-var-lst (new old l)subst-var-lst737,32079
(defun convert-type-set-to-term (x ts ens w ttree)convert-type-set-to-term747,32387
(defun convert-type-prescription-to-term (tp ens wrld)convert-type-prescription-to-term789,34338
(defun all-runes-in-lmi (lmi wrld ans)all-runes-in-lmi813,35524
(defun all-runes-in-lmi-lst (lmi-lst wrld ans)all-runes-in-lmi-lst828,36119
(defun all-runes-in-var-to-runes-alist (alist ans)all-runes-in-var-to-runes-alist833,36327
(defun all-runes-in-var-to-runes-alist-lst (lst ans)all-runes-in-var-to-runes-alist-lst839,36526
(defun all-runes-in-elim-sequence-lst (lst ans)all-runes-in-elim-sequence-lst847,36758
(defun all-runes-in-elim-sequence (elim-sequence ans)all-runes-in-elim-sequence853,36956
(defun all-runes-in-ttree-fc-derivation-lst (lst ans)all-runes-in-ttree-fc-derivation-lst868,37637
(defun all-runes-in-ttree-find-equational-poly-lst (lst ans)all-runes-in-ttree-find-equational-poly-lst877,37986
(defun all-runes-in-ttree (ttree ans)all-runes-in-ttree887,38403
(defun all-runes-in-ttree-lst (lst ans)all-runes-in-ttree-lst1014,42576
(defdoc introduction-to-the-tau-systemintroduction-to-the-tau-system1021,42764
(defdoc dealing-with-tau-problemsdealing-with-tau-problems1248,54244
(defdoc future-work-related-to-the-tau-systemfuture-work-related-to-the-tau-system1388,61372
(defrec tau-interval (domain (lo-rel . lo) . (hi-rel . hi)) t)tau-interval1857,85106
(defconst *tau-empty-interval**tau-empty-interval*2028,93268
(defun tau-empty-intervalp (int)tau-empty-intervalp2041,93685
(defun <?-number-v-rational (rel x k)<?-number-v-rational2192,99434
(defun <?-rational-v-number (rel k x)<?-rational-v-number2218,100229
(defun eval-tau-interval1 (interval x)eval-tau-interval12244,101024
(defun eval-tau-interval (interval evg)eval-tau-interval2258,101606
(defun decode-tau-interval (interval e skip-domain-flg)decode-tau-interval2273,102175
(defrec tautau2311,104017
(defconst *tau-empty**tau-empty*2459,109807
(defconst *nil-singleton-evg-list* (cdr *nil*))*nil-singleton-evg-list*2478,110551
(defconst *tau-t* (make tau*tau-t*2480,110600
(defconst *tau-nil* (make tau*tau-nil*2487,110828
(defconst *tau-non-nil* (make tau*tau-non-nil*2494,111083
(defconst *tau-contradiction* :contradiction)*tau-contradiction*2580,115734
(defrec signature-rule (input-tau-listsignature-rule2615,117881
(defrec big-switch-rule (formals switch-var switch-var-pos body) nil)big-switch-rule2671,121049
(defun tau-simple-implicants (sign pred wrld)tau-simple-implicants2676,121271
(defun tau-pair-member1 (index pairs)tau-pair-member12688,121780
(defun tau-pair-member (pair pairs)tau-pair-member2695,121999
(defun ev-fncall-w-tau-recog (fn evg-lst ens wrld)ev-fncall-w-tau-recog2815,128596
(defun bad-val-or-unknowns (bad-val pairs evg-lst ens wrld)bad-val-or-unknowns2996,136472
(defun exists-bad-valp (bad-val pairs evg-lst ens wrld)exists-bad-valp3023,137625
(defun all-eval-valp (good-val pairs evg-lst ens wrld)all-eval-valp3049,138719
(defun delete-bad-vals (neg-evgs pos-pairs neg-pairs ens wrld)delete-bad-vals3073,139624
(defun delete-bad-vals1 (neg-evgs sign tau-pair ens wrld)delete-bad-vals13093,140362
(defun tau-pairs-subsetp (pairs1 pairs2)tau-pairs-subsetp3133,141956
(defun tau-pairs-near-subsetp (pairs1 pairs2 e)tau-pairs-near-subsetp3146,142430
(defun tau-pairs-intersectionp (pairs1 pairs2)tau-pairs-intersectionp3173,143837
(defun insert-tau-pair (pair pairs)insert-tau-pair3189,144411
(defun interval-decider (lo-rel lo hi-rel hi rel k)interval-decider3267,147289
(defun signate (sign x)signate3291,148368
(defun reduce-sign/recog (tau sign recog ens wrld)reduce-sign/recog3376,151656
(defun every-neg-evg-in-tau-p1every-neg-evg-in-tau-p13837,170821
(defun every-neg-evg-in-tau-p (neg-evgs tau ens wrld)every-neg-evg-in-tau-p3882,173330
(defun lower-bound-<= (a-rel a b-rel b)lower-bound-<=4057,180827
(defun upper-bound->= (a-rel a b-rel b)upper-bound->=4072,181224
(defun lower-bound-> (a-rel a b-rel b)lower-bound->4084,181459
(defun upper-bound-< (a-rel a b-rel b)upper-bound-<4096,181693
(defun tau-subintervalp (interval1 interval2)tau-subintervalp4261,187802
(defun tau-implies (tau1 tau2 ens wrld)tau-implies4303,189973
(defun empty-tau-intervalp (lo-rel lo hi-rel hi)empty-tau-intervalp4349,192066
(defun singleton-tau-intervalp (lo-rel lo hi-rel hi)singleton-tau-intervalp4358,192289
(defun make-identity-interval (interval evg)make-identity-interval4375,192885
(defun identity-intervalp (int)identity-intervalp4406,194174
(defun delete-consecutive-integers-upward (k neg-evgs)delete-consecutive-integers-upward4487,198011
(defun delete-consecutive-integers-downward (k neg-evgs)delete-consecutive-integers-downward4519,199706
(defun collect-<?-x-k (rel k neg-evgs)collect-<?-x-k4552,201276
(defun collect-<?-k-x (rel k neg-evgs)collect-<?-k-x4588,203266
(defun adjust-upper-bound-with-neg-evgs (domain rel k neg-evgs)adjust-upper-bound-with-neg-evgs4607,203993
(defun adjust-lower-bound-with-neg-evgs (domain rel k neg-evgs)adjust-lower-bound-with-neg-evgs4638,205609
(defun squeeze-k (upper-boundp rel k)squeeze-k4669,207221
(defun set-tau-pos-evg (tau recog ens wrld)set-tau-pos-evg4717,209040
(defun positive-lower-boundp (lo-rel lo)positive-lower-boundp4751,210317
(defun nonnegative-lower-boundp (lo)nonnegative-lower-boundp4757,210432
(defun negative-upper-boundp (hi-rel hi)negative-upper-boundp4760,210492
(defun tighten-bound (tau domain upper-boundp rel k ens wrld)tighten-bound4766,210607
(defun add-to-tau1 (sign recog tau ens wrld)add-to-tau14927,218486
(defun add-recogs-to-tau1 (sign recog-lst tau ens wrld)add-recogs-to-tau15324,236134
(defun tau-interval-endpoint-to-sign-k-token (upper-boundp rel k)tau-interval-endpoint-to-sign-k-token5348,237224
(defun tau-union (tau1 tau2 ens wrld)tau-union5364,237845
(defun all-integers-in-range-excludedp1 (lo hi neg-evgs)all-integers-in-range-excludedp15440,241225
(defun all-integers-in-range-excludedp (lo-rel lo hi-rel hi neg-evgs)all-integers-in-range-excludedp5465,242515
(defun add-to-tau (sign recog tau ens wrld)add-to-tau5495,243828
(defun pos-evg-near-subsetp (pos-evg1 pos-evg2)pos-evg-near-subsetp5707,253885
(defun neg-evgs-near-subsetpneg-evgs-near-subsetp5730,254819
(defun tau-interval-endpoint-implication (ap arel k bp brel d)tau-interval-endpoint-implication6041,269521
(defun tau-interval-near-subsetp (interval1 interval2)tau-interval-near-subsetp6169,274090
(defun tau-near-subsetp (tau1 tau2 ens wrld)tau-near-subsetp6350,284088
(defun tau-put (p-sign p-recog q-sign q-recog ens wrld)tau-put6918,310329
(defun tau-put* (p-sign p-recog q-sign q-recog ens wrld)tau-put*7198,321402
(defun tau-put*-tau (p-sign p-recog tau ens wrld)tau-put*-tau7271,324619
(defun tau-put*-interval-endpoints (p-sign p-recog r-interval ens wrld)tau-put*-interval-endpoints7333,326941
(defun tau-put*-recogs (p-sign p-recog r-sign r-recogs ens wrld)tau-put*-recogs7377,328635
(defconst *non-tau-monadic-boolean-functions**non-tau-monadic-boolean-functions*7466,333198
(defun classicalp (fn wrld)classicalp7470,333298
(defun classical-fn-list-p (names wrld)classical-fn-list-p7491,334082
(defun monadic-boolean-fnp (fn ens wrld)monadic-boolean-fnp7497,334260
(defun putprop-if-different (sym prop val wrld)putprop-if-different7530,335366
(defun tau-visit-function-introduction (fn wrld)tau-visit-function-introduction7541,335731
(defun tau-visit-function-introductions (fns wrld)tau-visit-function-introductions7575,337292
(defun putprop-tau-pair (fn wrld)putprop-tau-pair7581,337502
(defun initialize-tau-pred (fn wrld)initialize-tau-pred7599,338294
(defun initialize-tau-preds (fns wrld)initialize-tau-preds7634,340067
(defun tau-boolean-formp (hyps concl wrld)tau-boolean-formp7639,340250
(defun tau-eval-formp (hyps concl wrld)tau-eval-formp7654,340762
(defun set-tau-runes (flg val wrld)set-tau-runes7665,341178
(defun add-tau-boolean-rule (rune hyps concl wrld)add-tau-boolean-rule7686,342090
(defun add-tau-eval-rule (rune hyps concl wrld)add-tau-eval-rule7710,343232
(defun tau-like-subject-criterion (criterion x)tau-like-subject-criterion7749,345180
(defun tau-like-term (term criterion wrld)tau-like-term7765,345891
(defun tau-like-term-listp (lst criterion wrld)tau-like-term-listp7863,350097
(defun tau-conjunctive-formp (hyps concl wrld)tau-conjunctive-formp7888,351242
(defun tau-simple-formp (hyps concl wrld)tau-simple-formp7921,352552
(defun add-tau-simple-rule (rune hyps concl ens wrld)add-tau-simple-rule7930,352897
(defun convert-tau-like-terms-to-tau (complete-flg terms ens wrld)convert-tau-like-terms-to-tau7959,354465
(defun add-tau-conjunctive-rule (rune hyps concl ens wrld)add-tau-conjunctive-rule7981,355295
(defun partition-signature-hyps-into-tau-alist-and-otherspartition-signature-hyps-into-tau-alist-and-others8068,359188
(defun tau-boolean-signature-formp (hyps concl)tau-boolean-signature-formp8111,361373
(defun tau-signature-formp (hyps concl wrld)tau-signature-formp8149,362809
(defun replace-vars-by-bindings (vars alist)replace-vars-by-bindings8255,367099
(defun add-tau-signature-rule (rune form hyps concl ens wrld)add-tau-signature-rule8265,367475
(defun switch-varp (v term wrld)switch-varp8366,372111
(defun tau-big-switch-equationp (term wrld)tau-big-switch-equationp8381,372567
(defun tau-big-switch-var (term)tau-big-switch-var8418,373867
(defun tau-big-switch-formp (hyps concl wrld)tau-big-switch-formp8439,374678
(defun add-tau-big-switch-rule (rune hyps concl wrld)add-tau-big-switch-rule8443,374791
(defun tau-mv-nth-synonym-formp (hyps concl)tau-mv-nth-synonym-formp8465,375673
(defun add-tau-mv-nth-synonym-rule (rune hyps concl wrld)add-tau-mv-nth-synonym-rule8480,376117
(defrec bounder-correctnessbounder-correctness8496,376726
(defun all-cars-nil (pairs)all-cars-nil8543,378885
(defun find-subject-bounder-link-term (pairs pairs0)find-subject-bounder-link-term8548,379027
(defun tau-bounder-doms-extraction (term ivars ivar)tau-bounder-doms-extraction8568,380027
(defun tau-bounder-hyp-extractiontau-bounder-hyp-extraction8594,381079
(defconst *all-interval-domains**all-interval-domains*8671,384034
(defun acceptable-domains-for-bounderacceptable-domains-for-bounder8674,384110
(defun bounder-args (ivars ivar-to-svar-pos-alist)bounder-args8689,384732
(defun tau-bounder-formp (term wrld)tau-bounder-formp8695,384944
(defun pairwise-subsetp-eq (doms-lst1 doms-lst2)pairwise-subsetp-eq8913,395837
(defun bounder-subsumedp (bc1 bc2)bounder-subsumedp8919,396052
(defun bounder-subsumedp-by-some (bc bounders)bounder-subsumedp-by-some8939,397096
(defun delete-some-subsumed-bounders (bc bounders)delete-some-subsumed-bounders8944,397284
(defun add-bounder-to-bounders (bc bounders)add-bounder-to-bounders8952,397583
(defun add-tau-bounder-rule (rune form j bc wrld)add-tau-bounder-rule8956,397756
(defun strip-force-and-case-split (lst)strip-force-and-case-split9000,399666
(defun strip-force-and-case-split-in-hyps-of-pairs (pairs)strip-force-and-case-split-in-hyps-of-pairs9009,399997
(defun acceptable-tau-rulep (pair wrld)acceptable-tau-rulep9075,403399
(defun acceptable-tau-rulesp (flg pairs wrld)acceptable-tau-rulesp9091,404027
(defun acceptable-tau-rules (pairs wrld)acceptable-tau-rules9105,404555
(defun cross-prod1 (a lst2)cross-prod19115,404930
(defun cross-prod (lst1 lst2)cross-prod9120,405072
(defun cnf-dnf (sign term cnfp)cnf-dnf9125,405230
(defun split-on-conjoined-disjunctions (lst)split-on-conjoined-disjunctions9198,408249
(defun split-on-conjoined-disjunctions-in-hyps-of-pairs (pairs)split-on-conjoined-disjunctions-in-hyps-of-pairs9214,408799
(defun chk-acceptable-tau-rule (name term ctx wrld state)chk-acceptable-tau-rule9231,409680
(defun add-tau-rule1 (lost-rune-action rune pairs ens wrld wrld0)add-tau-rule19291,412649
(defun add-tau-rule (first-visitp rune term ens wrld0)add-tau-rule9364,416258
(defun discover-tau-pred (fn ens wrld)discover-tau-pred9427,419492
(defun discover-tau-preds (fns ens wrld)discover-tau-preds9457,420955
(defun tau-rules-from-type-prescriptions (tp-lst fn ens wrld wrld0)tau-rules-from-type-prescriptions9462,421142
(defun original-def-body1 (fn def-bodies)original-def-body19530,424310
(defun original-def-body (fn wrld)original-def-body9536,424532
(defun tau-like-propositionp (var term wrld)tau-like-propositionp9543,424762
(defun expand-tau-like-proposition (term)expand-tau-like-proposition9580,426468
(defun add-only-simple-and-conjunctive-tau-rules (rune pairs ens wrld)add-only-simple-and-conjunctive-tau-rules9628,428797
(defun convert-normalized-term-to-pairs (rhyps term ans)convert-normalized-term-to-pairs9652,429559
(defun complementaryp (lit1 lit2)complementaryp9729,432218
(defun subsumes-but-for-one-negation (hyps1 hyps2 ancestor-lits)subsumes-but-for-one-negation9757,433435
(defun remove-ancestor-literals-from-pairs1 (pair1 pairs ancestor-lits)remove-ancestor-literals-from-pairs110003,445687
(defun remove-ancestor-literals-from-pairs (pairs)remove-ancestor-literals-from-pairs10031,446821
(defun convert-term-to-pairs (term ens wrld)convert-term-to-pairs10046,447386
(defun tau-subrs (rune fn formals rhs ens wrld)tau-subrs10108,449962
(defun tau-visit-defuns1 (fns ens wrld wrld0)tau-visit-defuns110151,451702
(defun tau-visit-defuns (fns auto-modep ens wrld0)tau-visit-defuns10202,453734
(defun tau-visit-defun (fn auto-modep ens wrld0)tau-visit-defun10231,455048
(defun corollaries-and-runes-of-enabled-rulescorollaries-and-runes-of-enabled-rules10286,458311
(defun tau-visit-defthm1 (first-visitp terms-and-runes ens wrld wrld0)tau-visit-defthm110318,459776
(defun tau-visit-defthm (first-visitp name auto-modep ens wrld0)tau-visit-defthm10342,460827
(defun tau-visit-event (first-visitp ev-type namex auto-modep enstau-visit-event10360,461616
(defun apply-conjunctive-tau-rule (tau1 tau2 ens wrld)apply-conjunctive-tau-rule10421,464420
(defun apply-conjunctive-tau-rules2 (conjunctive-rules tau ens wrld changedp)apply-conjunctive-tau-rules210450,465735
(defun apply-conjunctive-tau-rules1 (conjunctive-rules tau ens wrld max-loop)apply-conjunctive-tau-rules110481,466945
(defun apply-conjunctive-tau-rules (tau ens wrld calist)apply-conjunctive-tau-rules10532,469697
(defun add-to-tau! (sign recog tau ens wrld calist)add-to-tau!10550,470410
(defun all-tau-emptyp (lst)all-tau-emptyp10583,472044
(defun all-unrestricted-signature-rulesp (sigrules)all-unrestricted-signature-rulesp10588,472189
(defun disjoin-intervals (interval1 interval2)disjoin-intervals10636,474733
(defun conjoin-intervals (interval1 interval2)conjoin-intervals10736,479521
(defun combine-pos/neg-pairs-from-tau1 (sign pos-evg1 pairs1 pos-evg2 pairs2 ens wrld)combine-pos/neg-pairs-from-tau110861,484589
(defun augment-pos/neg-pairs-with-implicit-numeric-recogsaugment-pos/neg-pairs-with-implicit-numeric-recogs10950,488515
(defun combine-pos/neg-pairs-from-tau (sign tau1 tau2 ens wrld)combine-pos/neg-pairs-from-tau10979,489707
(defun combine-tau (tau1 tau2 ens wrld)combine-tau11003,490686
(defun push-mv-nth-down (i term)push-mv-nth-down11124,496944
(defun tau-expand-big-switch (body switch-var switch-tau var-alist ens wrld)tau-expand-big-switch11145,497676
(defun deconstruct-conjunction (sign a b c)deconstruct-conjunction11200,500108
(defun ok-to-fire-signature-rulep1 (formal-tau-lst actual-tau-lst ens wrld)ok-to-fire-signature-rulep111230,501075
(defun smart-member-equal-+- (lit clause)smart-member-equal-+-11258,502604
(defmacro recursivep (fn wrld)recursivep11302,504674
(defun find-first-acceptable-domain (actual-dom acceptable-domains)find-first-acceptable-domain11311,504905
(defun tau-lst-with-acceptable-domainsp (actual-tau-lst doms-lst)tau-lst-with-acceptable-domainsp11343,506888
(defun collect-bounder-args (actual-tau-lst doms-lst bounder-args)collect-bounder-args11379,508738
(defun bounding-interval (bc actual-tau-lst wrld)bounding-interval11411,510507
(defun conjoin-bounding-intervals (bounders actual-tau-lst wrld)conjoin-bounding-intervals11437,511537
(defun apply-tau-bounders (bounders actual-tau-lst ens wrld calist)apply-tau-bounders11450,512042
(defun tau-interval-equal-decider (int1 int2)tau-interval-equal-decider11499,514139
(defun tau-interval-<-decider (int1 int2)tau-interval-<-decider11551,516267
(defun tau-term (term tau-alist type-alist pot-lst ens wrld calist)tau-term11593,517883
(defun tau-term-lst (vars terms tau-alist type-alist pot-lst ens wrld calist)tau-term-lst11987,536193
(defun tau-rewrite (term tau-alist type-alist pot-lst ens wrld calist)tau-rewrite12021,537709
(defun relieve-dependent-hyps (hyps formals actualsrelieve-dependent-hyps12078,540042
(defun ok-to-fire-signature-rulep (sigrule actuals actual-tau-lstok-to-fire-signature-rulep12119,542196
(defun apply-signature-tau-rule (sigrule actuals actual-tau-lstapply-signature-tau-rule12136,542939
(defun apply-signature-tau-rules1 (sigrules actuals actual-tau-lst tauapply-signature-tau-rules112157,543968
(defun apply-signature-tau-rules (sigrules actuals actual-tau-lst tauapply-signature-tau-rules12192,545659
(defun tau-assume-basic (sign term tau-alist type-alist pot-lst ens wrld calist)tau-assume-basic12213,546851
(defun tau-assume (sign term tau-alist type-alist pot-lst ens wrld calist)tau-assume12257,548810
(defun annotate-clause-with-key-numbers (clause max i wrld)annotate-clause-with-key-numbers12590,566924
(defun tau-clause1p (triples tau-alist type-alist pot-lst ens wrld calist)tau-clause1p12614,567838
(defun tau-get-all-preds (wrld ans)tau-get-all-preds12663,569970
(defun tau-get-stats-new-max-block (pred prop val-len block)tau-get-stats-new-max-block12669,570202
(defun tau-size (tau)tau-size12688,570811
(defun tau-get-stats-on-implicant-sizes (preds wrld ans max-block)tau-get-stats-on-implicant-sizes12694,571001
(defun decode-recog (sign recog e)decode-recog12717,571995
(defun decode-recog-lst (sign lst e)decode-recog-lst12731,572448
(defun decode-tau1 (tau e)decode-tau112736,572617
(defun decode-tau (tau e)decode-tau12753,573317
(defun decode-tau-conjunctive-rule (tau)decode-tau-conjunctive-rule12817,575530
(defun decode-tau-conjunctive-rules (lst)decode-tau-conjunctive-rules12836,576332
(defun decode-tau-lst (lst e-lst)decode-tau-lst12841,576519
(defun decode-tau-alist (alist seen)decode-tau-alist12848,576807
(defun decode-tau-signature-rule (flg fn sr wrld)decode-tau-signature-rule12856,577148
(defun decode-tau-signature-rules1 (flg fn sr-lst wrld)decode-tau-signature-rules112894,578743
(defun decode-tau-signature-rules2 (i fn mv-lst wrld)decode-tau-signature-rules212899,578974
(defun decode-tau-signature-rules (flg fn sr-lst wrld)decode-tau-signature-rules12906,579307
(defun tau-get-all-sig-fns (wrld fns-seen)tau-get-all-sig-fns12924,580151
(defun some-slot-has-multiple-tau-sigs (slots)some-slot-has-multiple-tau-sigs12932,580548
(defun count-tau-sigs-by-slot (slots)count-tau-sigs-by-slot12937,580722
(defun collect-rules-with-dependent-hyps (fn i rules wrld ans)collect-rules-with-dependent-hyps12942,580884
(defun collect-rules-with-dependent-hyps-across-mv (fn i mv-lst wrld ans)collect-rules-with-dependent-hyps-across-mv12951,581247
(defun tau-get-stats-on-signatures1 (fn wrldtau-get-stats-on-signatures112957,581526
(defun tau-get-stats-on-signatures (fns wrldtau-get-stats-on-signatures13000,583357
(defun collect-tau-big-switches (wrld ans)collect-tau-big-switches13031,585169
(defun tau-sum-lst (x)tau-sum-lst13038,585459
(defun tau-get-stats (wrld)tau-get-stats13044,585693
(defmacro tau-status (&key (system 'nil system-p) (auto-mode 'nil auto-mode-p))tau-status13095,587900
(defun tau-data-fn (fn wrld)tau-data-fn13164,590416
(defmacro tau-data (fn)tau-data13205,592103
(defun all-fnnames-world1 (trips logicp wrld ans)all-fnnames-world113244,593431
(defun all-fnnames-world (mode wrld)all-fnnames-world13261,594175
(defun tau-data-fns (fns wrld ans)tau-data-fns13272,594513
(defun tau-database (wrld)tau-database13281,594831
(defun initialize-tau-globals (wrld)initialize-tau-globals13338,597423
(defun collect-tau-relevant-triples (wrld ans)collect-tau-relevant-triples13365,598194
(deflabel boundersbounders13380,598966

rewrite.lisp,35784
(defrec congruence-rule (nume equiv . rune) t)congruence-rule268,13538
(defconst *geneqv-iff**geneqv-iff*427,21586
(defun refinementp (equiv1 equiv2 wrld)refinementp445,22361
(defun geneqv-refinementp1 (coarsenings geneqv)geneqv-refinementp1506,24900
(defun geneqv-refinementp (equiv geneqv wrld)geneqv-refinementp518,25339
(defun some-congruence-rule-disabledp (geneqv ens)some-congruence-rule-disabledp572,28274
(defun filter-geneqv1 (geneqv ens)filter-geneqv1578,28503
(defun filter-geneqv (geneqv ens)filter-geneqv584,28752
(defun some-geneqv-disabledp (lst ens)some-geneqv-disabledp598,29232
(defun filter-geneqv-lst1 (lst ens)filter-geneqv-lst1603,29408
(defun filter-geneqv-lst (lst ens)filter-geneqv-lst608,29573
(defun refinementp1 (equiv1 coarsenings1 equiv2)refinementp1627,30350
(defun pair-congruence-rules-with-coarsenings (geneqv wrld)pair-congruence-rules-with-coarsenings640,30844
(defun add-to-cr-and-coarseningsadd-to-cr-and-coarsenings652,31324
(defun union-geneqv1 (geneqv1 old-crs-and-coarsenings wrld)union-geneqv1702,33574
(defun union-geneqv (geneqv1 geneqv2 wrld)union-geneqv729,35029
(defun pairwise-union-geneqv (lst1 lst2 wrld)pairwise-union-geneqv749,35845
(defun geneqv-lst1 (congruences geneqv ens wrld)geneqv-lst1766,36572
(defun geneqv-lst (fn geneqv ens wrld)geneqv-lst872,41694
(defun subst-expr1 (new old term)subst-expr1983,46700
(defun subst-expr1-lst (new old args)subst-expr1-lst993,47082
(defun subst-expr-error (const)subst-expr-error1003,47414
(defun subst-expr (new old term)subst-expr1010,47661
(defun scons-term (fn args ens wrld state ttree)scons-term1088,51739
(defun subst-equiv-expr1 (equiv new old geneqv term ens wrld state ttree)subst-equiv-expr11154,54301
(defun subst-equiv-expr1-lst (equiv new old geneqv-lst args ens wrld state ttree)subst-equiv-expr1-lst1209,57055
(defun subst-equiv-expr (equiv new old geneqv term ens wrld state ttree)subst-equiv-expr1232,57980
(defun ffnnamesp (fns term)ffnnamesp1245,58415
(defun ffnnamesp-lst (fns l)ffnnamesp-lst1260,58967
(defun collect-ffnnames (fns term ans)collect-ffnnames1270,59115
(defun collect-ffnnames-lst (fns l ans)collect-ffnnames-lst1293,59983
(defun comm-equal (fn lhs rhs term)comm-equal1300,60168
(defun member-term2 (fn lhs rhs cl)member-term21314,60559
(defun member-complement-term2 (fn lhs rhs cl)member-complement-term21328,61026
(defun member-complement-term1 (lit cl)member-complement-term11337,61348
(defun member-term (lit cl)member-term1352,61794
(defun member-complement-term (lit cl)member-complement-term1367,62342
(defun instr-listp (l)instr-listp1385,62982
(defun spliced-instr-listp (l)spliced-instr-listp1404,63805
(defun next-tag (l)next-tag1422,64539
(defun if-compile-formal (var rformals i)if-compile-formal1430,64752
(defun ffnnamep-hide (fn term lambda-exp)ffnnamep-hide1445,65404
(defun ffnnamep-hide-lst (fn l lambda-exp)ffnnamep-hide-lst1464,66144
(defun if-compile (term lambda-exp ac rformals)if-compile1476,66432
(defun if-compile-lst (l lambda-exp ac rformals)if-compile-lst1575,71201
(defun if-interp-assume-true (not-flg term assumptions)if-interp-assume-true1630,74357
(defun if-interp-switch (assumptions)if-interp-switch1650,75178
(defun if-interp-assumed-value0 (var assumptions)if-interp-assumed-value01663,75677
(defun if-interp-assumed-value1 (term assumptions)if-interp-assumed-value11674,76072
(defun if-interp-assumed-value2-equal-constant (arg const1 assumptions)if-interp-assumed-value2-equal-constant1686,76566
(defun if-interp-assumed-value2 (fn arg1 arg2 assumptions)if-interp-assumed-value21736,79074
(defun if-interp-assumed-value3 (term assumptions)if-interp-assumed-value31774,80880
(defun if-interp-assumed-value4 (term assumptions)if-interp-assumed-value41791,81638
(defun if-interp-assumed-value-x (term assumptions)if-interp-assumed-value-x1808,82429
(defun if-interp-assumed-value (term assumptions)if-interp-assumed-value1841,83935
(defun convert-assumptions-to-clause-segment (assumptions ans known-constants)convert-assumptions-to-clause-segment1859,84703
(defun convert-clause-to-assumptions (clause ans)convert-clause-to-assumptions1982,90789
(defun simplifiable-mv-nth1 (n cons-term alist)simplifiable-mv-nth12004,91896
(defun simplifiable-mv-nth (term alist)simplifiable-mv-nth2033,93136
(defun simplifiable-mv-nthp (term alist)simplifiable-mv-nthp2060,94315
(defun call-stack (fn lst stack assumptions ac)call-stack2069,94532
(defun ret-stack (lst stack)ret-stack2192,99758
(defun extra-info-lit-p (lit)extra-info-lit-p2196,99863
(defun subsetp-equal-mod-extra-info-lits (x y)subsetp-equal-mod-extra-info-lits2204,100096
(defun quick-and-dirty-subsumption-replacement-step1 (cl1 cl2)quick-and-dirty-subsumption-replacement-step12213,100411
(defun quick-and-dirty-subsumption-replacement-step (cl1 lst)quick-and-dirty-subsumption-replacement-step2234,101271
(defstub quick-and-dirty-srs (cl1 ac) t)quick-and-dirty-srs2414,109310
(defun quick-and-dirty-srs-builtin (cl1 ac)quick-and-dirty-srs-builtin2416,109352
(defattach quick-and-dirty-srs quick-and-dirty-srs-builtin)quick-and-dirty-srs2421,109471
(defun if-interp-add-clause (assumptions cl ac pflg)if-interp-add-clause2423,109532
(defun if-interp (instrs stack frame-ptr-stack assumptions ac pflg)if-interp2442,110294
(defun splice-instrs1 (instrs ans alist)splice-instrs12581,117884
(defun splice-instrs (instrs)splice-instrs2611,118975
(defun strip-branches (term assumptions lambda-exp)strip-branches2615,119089
(defun merge-length (l1 l2)merge-length2643,120206
(defun merge-sort-length (l)merge-sort-length2652,120546
(defun member-equal-+- (lit clause)member-equal-+-2658,120763
(defun arg1-almost-subsumes-arg2 (arg1 arg2)arg1-almost-subsumes-arg22672,121364
(defun find-subsumer-replacement (cl l)find-subsumer-replacement2721,123604
(defun remove-one-complement (lit cl)remove-one-complement2740,124585
(defun weak-disc-tree (x)weak-disc-tree2747,124869
(defun sweep-clauses1 (tree ac)sweep-clauses12757,125233
(defun sweep-clauses (tree)sweep-clauses2763,125457
(defun filter-with-and-without (x l with-lst without-lst)filter-with-and-without2767,125564
(defun disc-tree (x)disc-tree2785,126359
(defun find-clauses1 (clause tree ac)find-clauses12809,127536
(defun find-clauses (clause tree)find-clauses2829,128472
(defun remove-one-+- (x l)remove-one-+-2832,128542
(defun store-clause1 (clause undisc-lits tree)store-clause12838,128729
(defun store-clause (cl tree)store-clause2876,130226
(defun substitute1-ac (new old seq acc)substitute1-ac2895,130816
(defun substitute1 (new old seq)substitute12910,131323
(defun replace-clause1 (clause undisc-lits new-clause tree)replace-clause12915,131496
(defun replace-clause (clause new-clause tree)replace-clause2941,132516
(defun extra-info-lits (cl acc)extra-info-lits2946,132722
(defun rev-union-equal (x y)rev-union-equal2952,132918
(defun merge-extra-info-lits (cl cl0 tree)merge-extra-info-lits2961,133200
(defun subsumption-replacement-loop (todo done-tree again-flg)subsumption-replacement-loop2969,133459
(defun clausify (term assumptions lambda-exp sr-limit)clausify3022,135778
(defun find-rewriting-equivalence (lhs type-alist geneqv wrld ttree)find-rewriting-equivalence3063,137666
(defun obj-table (term ts ts-ttree obj geneqv wrld ttree)obj-table3133,141473
(defun rewrite-solidify-rec (bound term type-alist obj geneqv ens wrld ttreerewrite-solidify-rec3178,143230
(defconst *rewrite-equiv-solidify-iteration-bound**rewrite-equiv-solidify-iteration-bound*3309,148635
(defun rewrite-solidify (term type-alist obj geneqv ens wrld ttreerewrite-solidify3316,148835
(defun rewrite-if11 (term type-alist geneqv wrld ttree)rewrite-if113366,150703
(defun rewrite-if1rewrite-if13377,151099
(defun equal-mod-alist (term1 alist1 term2)equal-mod-alist3424,153029
(defun equal-mod-alist-lst (term1-lst alist1 term2-lst)equal-mod-alist-lst3458,154399
(defun member-equal-mod-alist (term1 alist1 term2-lst)member-equal-mod-alist3465,154634
(defun not-to-be-rewrittenp1 (fn lst)not-to-be-rewrittenp13471,154857
(defun not-to-be-rewrittenp (term alist terms-to-be-ignored-by-rewrite)not-to-be-rewrittenp3483,155202
(defun rewrite-recognizer (recog-tuple arg type-alist ens force-flg wrld ttreerewrite-recognizer3499,155917
(defun remove-invisible-fncalls (term invisible-fns)remove-invisible-fncalls3558,158476
(defun term-order+ (x1 x2 invisible-fns)term-order+3572,158902
(defun invisible-fns (fns alist acc)invisible-fns3709,164344
(defun loop-stopperp-rec (loop-stopper sbst wrld)loop-stopperp-rec3742,165544
(defun loop-stopperp (loop-stopper sbst wrld)loop-stopperp3760,166133
(defrec rewrite-rule (rune nume hyps equiv lhs rhsrewrite-rule3764,166257
(defun relevant-ground-lemmas (hyp wrld)relevant-ground-lemmas3820,169167
(defun search-ground-units1search-ground-units13830,169500
(defun search-ground-unitssearch-ground-units3891,172441
(defun if-tautologyp (term)if-tautologyp3905,173014
(defun expand-some-non-rec-fns (fns term wrld)expand-some-non-rec-fns3938,174537
(defun expand-some-non-rec-fns-lst (fns lst wrld)expand-some-non-rec-fns-lst3952,175126
(defun tautologyp (term wrld)tautologyp3959,175337
(defun make-true-list-cons-nest (term-lst)make-true-list-cons-nest4003,177350
(defun being-openedp-rec (fn fnstack)being-openedp-rec4014,177803
(defmacro being-openedp (fn fnstack clique)being-openedp4036,178917
(defun recursive-fn-on-fnstackp (fnstack)recursive-fn-on-fnstackp4056,179899
(defun fnstack-term-member (term fnstack)fnstack-term-member4069,180361
(defun var-counts1 (arg rhs acc)var-counts14318,192225
(defun var-counts1-lst (arg lst acc)var-counts1-lst4336,192731
(defun var-counts (lhs-args rhs)var-counts4345,193028
(defun count-ifs (term)count-ifs4399,196081
(defun count-ifs-lst (lst)count-ifs-lst4411,196458
(defun too-many-ifs0 (args counts diff ctx)too-many-ifs04441,197537
(defproxy too-many-ifs-pre-rewrite (* *) => *)too-many-ifs-pre-rewrite4471,198775
(defun too-many-ifs-pre-rewrite-builtin (args counts)too-many-ifs-pre-rewrite-builtin4473,198823
(defun occur-cnt-bounded (term1 term2 a m bound-m)occur-cnt-bounded4519,200323
(defun occur-cnt-bounded-lst (term1 lst a m bound-m)occur-cnt-bounded-lst4547,201432
(defun too-many-ifs1 (args val lhs rhs ctx)too-many-ifs14566,202210
(defproxy too-many-ifs-post-rewrite (* *) => *)too-many-ifs-post-rewrite4592,203191
(defun too-many-ifs-post-rewrite-builtin (args val)too-many-ifs-post-rewrite-builtin4594,203240
(defun all-args-occur-in-top-clausep (args top-clause)all-args-occur-in-top-clausep4611,203900
(defun cons-count-bounded-ac (x i)cons-count-bounded-ac4616,204109
(defun cons-count-bounded (x)cons-count-bounded4633,204793
(defun max-form-count (term)max-form-count4639,204901
(defun max-form-count-lst (lst acc)max-form-count-lst4715,208411
(defun controller-complexity1 (flg args controller-pocket)controller-complexity14726,208737
(defun controller-complexity (flg term controller-alist)controller-complexity4749,209681
(defun controller-pocket-simplerp (call result controller-alist)controller-pocket-simplerp4762,210257
(defun constant-controller-pocketp1 (args controller-pocket)constant-controller-pocketp14780,210981
(defun constant-controller-pocketp (term controller-alist)constant-controller-pocketp4789,211381
(defun some-controller-pocket-constant-and-non-controller-simplerpsome-controller-pocket-constant-and-non-controller-simplerp4800,211840
(defun rewrite-fncallp (call result cliquep top-clause current-clauserewrite-fncallp4816,212551
(defun rewrite-fncallp-listp (call lst cliquep top-clause current-clauserewrite-fncallp-listp4882,215529
(defun contains-rewriteable-callpcontains-rewriteable-callp4900,216199
(defun contains-rewriteable-callp-lstcontains-rewriteable-callp-lst4930,217518
(defrec linear-lemma ((nume . hyps) max-term concllinear-lemma4943,217969
(defrec current-literal (not-flg . atm) t)current-literal4955,218265
(defrec rewrite-constantrewrite-constant4957,218309
(defconst *default-rw-cache-state**default-rw-cache-state*5084,224277
(defconst *empty-rewrite-constant**empty-rewrite-constant*5087,224322
(defrec metafunction-contextmetafunction-context5110,225020
(defun ok-to-force (rcnst)ok-to-force5125,225652
(defun plist-to-alist (lst)plist-to-alist5214,229703
(defmacro adjust-rdepth (rdepth)adjust-rdepth5223,229985
(defun add-rewrite-args (extra-formals keyword-extra-formals alist)add-rewrite-args5232,230204
(defrec step-limit-recordstep-limit-record5252,231026
(defun step-limit-start (state)step-limit-start5267,231649
(defun step-limit-strictp (state)step-limit-strictp5276,231943
(defun initial-step-limit (wrld state)initial-step-limit5288,232362
(defun step-limit-error1 (ctx str start where state)step-limit-error15317,233795
(defmacro step-limit-error (superior-context-p)step-limit-error5329,234170
(defmacro decrement-step-limit (step-limit)decrement-step-limit5351,234913
(defmacro rewrite-entry (&rest args)rewrite-entry5373,235632
(deflabel free-variablesfree-variables5452,239288
(deflabel free-variables-type-prescriptionfree-variables-type-prescription5658,249881
(deflabel free-variables-examplesfree-variables-examples5753,253104
(deflabel free-variables-examples-rewritefree-variables-examples-rewrite5767,253673
(deflabel free-variables-examples-forward-chainingfree-variables-examples-forward-chaining6320,272877
(defconst *fake-rune-for-linear**fake-rune-for-linear*6519,279921
(defrec gframe (sys-fn bkptr . args) t)gframe6526,280108
(defparameter *deep-gstack* nil)*deep-gstack*6566,281840
(defmacro push-gframe (sys-fn bkptr &rest args)push-gframe6568,281874
(defparameter *saved-deep-gstack* nil)*saved-deep-gstack*6607,283469
(defmacro initial-gstack (sys-fn bkptr &rest args)initial-gstack6609,283509
(defun tilde-@-bkptr-phrase (calling-sys-fn called-sys-fn bkptr)tilde-@-bkptr-phrase6624,284076
(defun cw-gframe (i calling-sys-fn frame evisc-tuple)cw-gframe6672,286557
(defun cw-gstack1 (i calling-sys-fn lst evisc-tuple)cw-gstack16744,289545
(defun cw-gstack-fn (evisc-tuple frames)cw-gstack-fn6751,289855
(defmacro cw-gstack (&key (evisc-tuple 'nil evisc-tuplep) (frames 'nil))cw-gstack6813,292711
(defun restore-brr-globals1 (name new-alist old-alist)restore-brr-globals16975,301974
(defun restore-brr-globals (state)restore-brr-globals6984,302292
(defun save-brr-globals (state)save-brr-globals7012,303400
(defun get-brr-global (var state)get-brr-global7036,304348
(defun exit-brr-wormhole (state)exit-brr-wormhole7073,306213
(defmacro brr-wormhole (entry-lambda input-alist test-form aliases)brr-wormhole7082,306538
(defun initialize-brr-stack (state)initialize-brr-stack7134,308879
(defun lookup-brr-stack (var-name stack)lookup-brr-stack7153,309617
(defun clean-brr-stack1 (gstack stack)clean-brr-stack17165,310139
(defun clean-brr-stack (gstack stack)clean-brr-stack7171,310311
(defun get-brr-local (var state)get-brr-local7219,312899
(defun put-brr-local1 (gstack var val stack)put-brr-local17232,313524
(defun put-brr-local (var val state)put-brr-local7243,314006
(defun put-brr-local-lst (alist state)put-brr-local-lst7258,314682
(defun some-cdr-equalp (little big)some-cdr-equalp7263,314880
(defun push-brr-stack-frame (state)push-brr-stack-frame7271,315100
(defun pop-brr-stack-frame (state)pop-brr-stack-frame7302,316515
(defun decode-type-alist (type-alist)decode-type-alist7313,316966
(defun translate-break-condition (xterm ctx state)translate-break-condition7324,317400
(defun eval-break-condition (rune term ctx state)eval-break-condition7340,318018
(defconst *default-free-vars-display-limit* 30)*default-free-vars-display-limit*7357,318644
(defmacro set-free-vars-display-limit (n)set-free-vars-display-limit7359,318693
(defun free-vars-display-limit (state)free-vars-display-limit7369,319125
(defun limit-failure-reason (failures-remaining failure-reason elided-p)limit-failure-reason7379,319445
(defun limit-failure-reason-alist (failures-remaining alist elided-p)limit-failure-reason-alist7401,320479
(defun fix-free-failure-reason (failure-reason)fix-free-failure-reason7426,321705
(defun fix-free-failure-reason-alist (x acc)fix-free-failure-reason-alist7439,322057
(defun tilde-@-failure-reason-free-phrase (hyp-number alist level unify-substtilde-@-failure-reason-free-phrase7454,322459
(defun tilde-@-failure-reason-phrase1 (failure-reason level unify-substtilde-@-failure-reason-phrase17491,324202
(defun tilde-@-failure-reason-phrase (failure-reason level unify-substtilde-@-failure-reason-phrase7616,330682
(defun stuff-standard-oi (cmds state)stuff-standard-oi7630,331420
(deflabel break-rewritebreak-rewrite7655,332673
(deflabel break-lemmabreak-lemma7906,346196
(deflabel brr-commandsbrr-commands7987,349849
(defdoc dmrdmr8033,351947
(defun raw-mode-p (state)raw-mode-p8200,360620
(defun defun-mode-prompt-string (state)defun-mode-prompt-string8203,360688
(defun brr-prompt (channel state)brr-prompt8224,361202
(defun ts< (x y)ts<8238,361685
(defun add-to-type-alist-segments (ts term segs)add-to-type-alist-segments8264,362137
(defun merge-term-order (l1 l2)merge-term-order8277,362475
(defun merge-sort-term-order (l)merge-sort-term-order8284,362712
(defun sort-type-alist-segments (segs)sort-type-alist-segments8289,362902
(defun type-alist-segments (type-alist acc)type-alist-segments8301,363315
(defun print-terms (terms iff-flg wrld)print-terms8310,363639
(defun print-type-alist-segments (segs wrld)print-type-alist-segments8325,364097
(defun print-type-alist (type-alist wrld)print-type-alist8343,364837
(defun tilde-*-ancestors-stack-msg1 (i ancestors wrld evisc-tuple)tilde-*-ancestors-stack-msg18348,364994
(defun tilde-*-ancestors-stack-msg (ancestors wrld evisc-tuple)tilde-*-ancestors-stack-msg8372,366203
(defun brkpt1 (lemma target unify-subst type-alist ancestors initial-ttreebrkpt18376,366368
(defun brkpt2 (wonp failure-reason unify-subst gstack rewritten-rhs final-ttreebrkpt28612,375512
(defrec expand-hintexpand-hint8880,386336
(defun binds-to-constants-p (unify-subst)binds-to-constants-p8897,386710
(defun expand-permission-result1 (term expand-lst geneqv wrld)expand-permission-result18904,386983
(defun remove1-by-position (target-index lst acc)remove1-by-position8979,390874
(defun expand-permission-result (term rcnst geneqv wrld)expand-permission-result8989,391270
(defun expand-permission-p (term rcnst geneqv wrld)expand-permission-p9066,394349
(defun one-way-unify-restrictions1 (pat term restrictions)one-way-unify-restrictions19078,394886
(defun one-way-unify-restrictions (pat term restrictions)one-way-unify-restrictions9088,395249
(defun ev-fncall! (fn args state latches aok)ev-fncall!9094,395431
(defun ev-fncall-meta (fn args state)ev-fncall-meta9138,397340
(defun get-evg (q ctx)get-evg9172,398973
(defun ev-synp (synp-term unify-subst mfc state)ev-synp9184,399280
(defun bad-synp-alist1 (alist unify-subst vars-to-be-bound wrld)bad-synp-alist19216,400761
(defun bad-synp-alist1-lst (alist-lst unify-subst vars-to-be-bound wrld)bad-synp-alist1-lst9246,402048
(defun bind-free-info (x unify-subst vars-to-be-bound wrld)bind-free-info9253,402351
(defun evgs-or-t (lst alist)evgs-or-t9281,403507
(deflabel nu-rewriternu-rewriter9643,421459
(defparameter *nth-update-tracingp* nil)*nth-update-tracingp*9754,426259
(defparameter *lambda-abstractp* t)*lambda-abstractp*9757,426338
(defparameter *nu-memos* (make-array$ '(65535)))*nu-memos*9760,426412
(defparameter *nu-memos-ens* nil)*nu-memos-ens*9763,426499
(defparameter *nu-memos-wrld* nil)*nu-memos-wrld*9766,426571
(defparameter *ring-buffer-size* (the (integer 0 1000) 5))*ring-buffer-size*9769,426644
(defun-one-output initialize-nu-memos (i)initialize-nu-memos9783,427283
(defun-one-output clear-nu-memos1 (i)clear-nu-memos19794,427646
(defun-one-output clear-nu-memos (reallyp ens wrld)clear-nu-memos9813,428428
(defmacro this-item (x) `(car ,x))this-item9832,429240
(defmacro next-ptr (x) `(cadr ,x))next-ptr9833,429275
(defmacro prev-ptr (x) `(cddr ,x))prev-ptr9834,429310
(defun-one-output link-em (x y)link-em9845,429616
(defun-one-output destructive-get-memo1 (d1 d2 d3 ptr0 ptr1 ptr2)destructive-get-memo19850,429735
(defun-one-output destructive-get-memo (d1 d2 d3 rbuff)destructive-get-memo9898,431189
(defun get-memo (recursively term stack memo-alist)get-memo9912,431737
(defun-one-output destructive-retire-memo (item rbuff)destructive-retire-memo9967,433667
(defun-one-output destructive-insert-memo (item rbuff)destructive-insert-memo9979,434104
(defun-one-output nu-memo-stats1 (i buckets items full-buckets)nu-memo-stats19998,434735
(defun-one-output nu-memo-stats ()nu-memo-stats10015,435413
(defun memo-key1 (term)memo-key110029,435812
(defun bounded-length (lst ans max)bounded-length10060,437063
(defun memo-key (term stack)memo-key10071,437288
(defun mk (term stack)mk10095,438153
(defun show-rbuff1 (r s)show-rbuff110103,438354
(defun show-rbuff (r)show-rbuff10106,438451
(defun memo-exit (recursivelyp term stack flg term2 stack2 ttree2 memo-alist)memo-exit10121,439221
(defun nfix-quote (x)nfix-quote10167,440925
(defun bound-in-framep (var vars terms)bound-in-framep10188,441565
(defun non-rec-defun1 (lemmas ens ttree)non-rec-defun110197,441848
(defun non-rec-defun (fn ens wrld ttree)non-rec-defun10243,444149
(defun deref-var (var stack ens wrld ttree)deref-var10304,446777
(defun deref (term stack ens wrld ttree)deref10317,447244
(defun equal-derefs (term1 stack1 term2 stack2)equal-derefs10386,449497
(defun filter-args (formals vars actuals)filter-args10401,449936
(defun foccurrences (term1 term2 ans)foccurrences10409,450206
(defun foccurrences-lst (term lst ans)foccurrences-lst10438,451180
(defun every-var-at-most-oncep (vars body)every-var-at-most-oncep10445,451411
(defun every-actual-simple (args)every-actual-simple10455,451718
(defun make-clean-lambda-application (formals body args)make-clean-lambda-application10462,451909
(defun lambda-stack (stack term)lambda-stack10515,454267
(defun shorten-each-stack-to-len (n terms stacks)shorten-each-stack-to-len10542,455406
(defun all-equal-stacks (the-stack terms stacks)all-equal-stacks10553,455839
(defun non-quoted-stack (terms stacks)non-quoted-stack10562,456223
(defun cdr-all (x)cdr-all10568,456402
(defun len-common-tail (n terms stacks)len-common-tail10572,456498
(defun butlast-all-stacks (terms stacks n)butlast-all-stacks10577,456667
(defun min-stack-len (terms stacks)min-stack-len10584,456920
(defun reconcile-stacks (terms stacks)reconcile-stacks10594,457250
(defun reconcile-terms (terms exts)reconcile-terms10643,459192
(defun all-equal (x lst)all-equal10649,459366
(defun recon (terms stacks)recon10655,459524
(defun with-reconciliation-let-bindings (terms var)with-reconciliation-let-bindings10678,460513
(defmacro with-reconciliation (terms stacks common-stack body)with-reconciliation10684,460772
(defun lambda-stack-one-way-unify1 (pat term stack alist ens wrld ttree)lambda-stack-one-way-unify110717,461750
(defun lambda-stack-one-way-unify1-lst (pat-lst term-lst stack alistlambda-stack-one-way-unify1-lst10766,463599
(defun lambda-stack-one-way-unify (pat term stack ens wrld ttree)lambda-stack-one-way-unify10786,464423
(defun apply-abbrevs-to-lambda-stack1 (term stack ens wrld lemmas ttree)apply-abbrevs-to-lambda-stack110815,465423
(defun apply-abbrevs-to-lambda-stack (hitp term stack ens wrld state ttree)apply-abbrevs-to-lambda-stack10858,467506
(defconst *fake-rune-for-nu-rewriter**fake-rune-for-nu-rewriter*10955,471186
(defun nth-update-rewriter1-continuenth-update-rewriter1-continue10962,471333
(defun nth-update-rewriter1nth-update-rewriter111020,473416
(defun nth-update-rewriter1-lst (recursivelyp args stacknth-update-rewriter1-lst11567,496597
(defun nth-update-rewriter-targetp (term wrld)nth-update-rewriter-targetp11590,497603
(defun nth-update-rewriter-target-lstp (lst wrld)nth-update-rewriter-target-lstp11604,498214
(defun make-stack-from-alist (term alist)make-stack-from-alist11613,498459
(defun nth-update-rewriter (recursivep term alist ens wrld state)nth-update-rewriter11636,499355
(defun collect-by-position (sub-domain full-domain full-range)collect-by-position11752,504164
(defun make-lambda-application (formals body actuals)make-lambda-application11770,504867
(defun lambda-nest-hidep (term)lambda-nest-hidep11805,506083
(defun lambda-nest-unhide (term)lambda-nest-unhide11821,506538
(defun search-type-alist+ (term typ type-alist unify-subst ttree wrld)search-type-alist+11832,506830
(defun oncep (nume-runes match-free rune nume)oncep11852,507665
(defabbrev memo-activep (memo)memo-activep11866,508287
(defabbrev activate-memo (memo)activate-memo11869,508357
(defmacro zero-depthp (depth)zero-depthp11872,508422
(defmacro rdepth-error (form &optional preprocess-p)rdepth-error11889,509091
(defun bad-synp-hyp-msg1 (hyp bound-vars all-vars-bound-p wrld)bad-synp-hyp-msg111921,510795
(defun bad-synp-hyp-msg (hyps bound-vars all-vars-bound-p wrld)bad-synp-hyp-msg12075,519570
(defmacro sl-let (vars form &rest rest)sl-let12102,520857
(defmacro sl-let@par (vars form &rest rest)sl-let@par12113,521110
(defmacro rewrite-entry-extending-failure (unify-subst failure-reason formrewrite-entry-extending-failure12125,521478
(defun set-difference-assoc-eq (lst alist)set-difference-assoc-eq12140,522337
(defun extend-unify-subst (alist unify-subst)extend-unify-subst12150,522772
(defun relieve-hyp-synp (rune hyp0 unify-subst rdepth type-alist wrld staterelieve-hyp-synp12159,523051
(defun push-lemma? (rune ttree)push-lemma?12270,528183
(defmacro push-lemma+ (rune ttree rcnst ancestors rhs rewritten-rhs)push-lemma+12275,528269
(defmacro push-splitter? (rune ttree rcnst ancestors rhs rewritten-rhs)push-splitter?12290,528838
(defmacro prepend-step-limit (n form)prepend-step-limit12308,529560
(defrec rw-cache-entryrw-cache-entry12319,529908
(defmacro free-failure-p (r)free-failure-p12381,532565
(defabbrev combine-free-failure-reasons (r1 r2)combine-free-failure-reasons12384,532629
(defun combine-free-failure-alists (a1 a2)combine-free-failure-alists12397,533070
(defun combine-sorted-rw-cache-lists1 (l1 l2)combine-sorted-rw-cache-lists112438,534539
(defun split-psorted-list1 (lst acc)split-psorted-list112491,536902
(defun split-psorted-list (lst)split-psorted-list12499,537163
(defun merge-lexorder-fast (l1 l2)merge-lexorder-fast12512,537661
(defun merge-sort-lexorder-fast (l)merge-sort-lexorder-fast12529,538319
(defun sort-rw-cache-list (lst)sort-rw-cache-list12569,539968
(defun combine-rw-cache-lists (lst1 lst2)combine-rw-cache-lists12587,540572
(defun merge-rw-caches (alist1 alist2)merge-rw-caches12611,541536
(defmacro sorted-rw-cache-p (cache)sorted-rw-cache-p12643,543056
(defun merge-symbol-alistp (a1 a2)merge-symbol-alistp12649,543187
(defun merge-sort-symbol-alistp (alist)merge-sort-symbol-alistp12659,543472
(defun cdr-sort-rw-cache (cache)cdr-sort-rw-cache12671,543941
(defun combine-rw-caches (c1 c2)combine-rw-caches12686,544412
(defun unify-subst-subsetp (a1 a2)unify-subst-subsetp12704,545127
(defun rw-cache-list-lookup (unify-subst hyps recs)rw-cache-list-lookup12716,545515
(defstub relieve-hyp-failure-entry-skip-prelieve-hyp-failure-entry-skip-p12745,546819
(defun relieve-hyp-failure-entry-skip-p-builtin (rune unify-subst hyps ttreerelieve-hyp-failure-entry-skip-p-builtin12749,546910
(defmacro rw-cache-active-p (rcnst)rw-cache-active-p12758,547263
(defun assoc-rw-cache (key alist)assoc-rw-cache12762,547390
(defun put-assoc-rw-cache1 (key val alist)put-assoc-rw-cache112770,547618
(defun put-assoc-rw-cache (key val alist)put-assoc-rw-cache12782,548112
(defun relieve-hyp-failure-entry (rune unify-subst hyps ttree step-limit)relieve-hyp-failure-entry12791,548390
(defun maybe-extend-tag-tree (tag vals ttree)maybe-extend-tag-tree12816,549422
(defun accumulate-rw-cache1 (replace-p tag new-ttree old-ttree)accumulate-rw-cache112823,549599
(defun accumulate-rw-cache (replace-p new-ttree old-ttree)accumulate-rw-cache12870,551563
(defun accumulate-rw-cache? (replace-p new-ttree old-ttree)accumulate-rw-cache?12889,552483
(defun dumb-occur-var (var term)dumb-occur-var12905,553168
(defun dumb-occur-var-lst (var lst)dumb-occur-var-lst12915,553497
(defun restrict-alist-to-all-vars1 (alist term)restrict-alist-to-all-vars112921,553661
(defun all-vars-boundp (term alist)all-vars-boundp12939,554406
(defun all-vars-lst-boundp (lst alist)all-vars-lst-boundp12947,554688
(defun restrict-alist-to-all-vars (alist term)restrict-alist-to-all-vars12956,554971
(defun push-rw-cache-entry (entry tag rune ttree)push-rw-cache-entry12979,555968
(defstub rw-cache-debugrw-cache-debug13001,556726
(defstub rw-cache-debug-actionrw-cache-debug-action13005,556822
(defun rw-cache-debug-builtin (rune target unify-subst failure-reasonrw-cache-debug-builtin13009,556925
(defun rw-cache-debug-action-builtin (rune target unify-subst failure-reasonrw-cache-debug-action-builtin13015,557150
(defun rw-cacheable-failure-reason-builtin (failure-reason)rw-cacheable-failure-reason-builtin13033,557781
(defun rw-cacheable-nil-tag (failure-reason)rw-cacheable-nil-tag13046,558315
(defun note-relieve-hyp-failure (rune unify-subst failure-reason ttree hypsnote-relieve-hyp-failure13067,559189
(defun replace-free-rw-cache-entry1 (unify-subst hyps entry recs)replace-free-rw-cache-entry113117,561644
(defun replace-free-rw-cache-entry (entry tag rune unify-subst hyps ttree)replace-free-rw-cache-entry13138,562648
(defun rw-cache-alist-nil-tag-p (alist)rw-cache-alist-nil-tag-p13157,563318
(defabbrev merge-free-failure-reasons-nil-tag (r1 r2)merge-free-failure-reasons-nil-tag13171,563933
(defun merge-free-failure-alists-nil-tag (a1 a2)merge-free-failure-alists-nil-tag13184,564513
(defun note-rw-cache-free-nil-tag (rune unify-subst hyps ttreenote-rw-cache-free-nil-tag13230,566295
(defun note-relieve-hyps-failure-free (rune unify-subst hyps ttree old-entrynote-relieve-hyps-failure-free13281,568423
(defun rw-cache-enter-context (ttree)rw-cache-enter-context13318,569824
(defun erase-rw-cache (ttree)erase-rw-cache13326,570099
(defun rw-cache-exit-context (old-ttree new-ttree)rw-cache-exit-context13335,570323
(defun restore-rw-cache-any-tag (new-ttree old-ttree)restore-rw-cache-any-tag13363,571582
(defun cons-tag-trees-rw-cache (ttree1 ttree2)cons-tag-trees-rw-cache13386,572770
(defun normalize-rw-any-cache (ttree)normalize-rw-any-cache13457,575590
(defun cons-tag-trees-rw-cache-first (ttree1 ttree2)cons-tag-trees-rw-cache-first13469,575986
(defun alist-keys-subsetp (x keys)alist-keys-subsetp13483,576418
(defmacro tag-tree-tags-subsetp (ttree tags)tag-tree-tags-subsetp13489,576572
(defun rw-cache (ttree)rw-cache13495,576685
(defun rw-cached-failure-pair (unify-subst rw-cache-alist)rw-cached-failure-pair13510,577144
(defun extend-rw-cache-alist-free (rcnst new-unify-substextend-rw-cache-alist-free13531,578114
(defun rw-cache-add-failure-reason (rcnst new-unify-substrw-cache-add-failure-reason13551,579131
(defun rewrite (term alist bkptr ; &extra formalsrewrite13576,580154
(defun rewrite-solidify-plus (term ; &extra formalsrewrite-solidify-plus14265,611872
(defun rewrite-if (test unrewritten-test left right alist ; &extra formalsrewrite-if14324,614637
(defun rewrite-args (args alist bkptr; &extra formalsrewrite-args14475,622630
(defun rewrite-primitive (fn args ; &extra formalsrewrite-primitive14503,623687
(defun rewrite-equal (lhs rhs lhs-ancestors rhs-ancestors ; &extra formalsrewrite-equal14541,625202
(defun relieve-hyprelieve-hyp14844,639206
(defun relieve-hyps1-iter (rune target hyps backchain-limit-lstrelieve-hyps1-iter15216,658589
(defun relieve-hyps1 (rune target hyps backchain-limit-lstrelieve-hyps115253,660550
(defun relieve-hyps1-free-1relieve-hyps1-free-115412,668177
(defun relieve-hyps1-free-2relieve-hyps1-free-215531,673712
(defun relieve-hyps (rune target hyps backchain-limit-lstrelieve-hyps15720,681813
(defun rewrite-with-lemma (term lemma ; &extra formalsrewrite-with-lemma15855,688112
(defun rewrite-with-lemmas1 (term lemmasrewrite-with-lemmas116202,705554
(defun rewrite-fncall (rule term ; &extra formalsrewrite-fncall16246,707501
(defun rewrite-with-lemmas (term ; &extra formalsrewrite-with-lemmas16632,727917
(defun rewrite-linear-term (term alist ; &extra formalsrewrite-linear-term16773,734734
(defun rewrite-linear-term-lst (term-lst ttrees ; &extra formalsrewrite-linear-term-lst16862,738749
(defun add-linear-lemma (term lemma ; &extra formalsadd-linear-lemma16915,741120
(defun add-linear-lemmas (term linear-lemmas ; &extra formalsadd-linear-lemmas17153,752238
(defun multiply-alists2 (alist-entry1 alist-entry2 poly ; &extra formalsmultiply-alists217206,754451
(defun multiply-alists1 (alist-entry alist2 poly ; &extra formalsmultiply-alists117265,757100
(defun multiply-alists (alist1 alist2 poly ; &extra formalsmultiply-alists17312,758825
(defun multiply-polys1 (alist1 const1 rel1 alist2 const2 rel2multiply-polys117368,760812
(defun multiply-polys (poly1 poly2 ; &extra formalsmultiply-polys17540,768426
(defun multiply-pots2 (poly big-poly-list new-poly-list ; &extra formalsmultiply-pots217602,771026
(defun multiply-pots1 (poly-list big-poly-list new-poly-list ; &extra formalsmultiply-pots117663,773149
(defun multiply-pots-super-filter (var-list pot-lst-to-look-in ; &extra formalsmultiply-pots-super-filter17712,774825
(defun multiply-pots-filter (var-list pot-lst-to-look-in ; &extra formalsmultiply-pots-filter17768,777000
(defun multiply-pots (var-list pot-lst-to-look-in ; &extra formalsmultiply-pots17822,779229
(defun add-multiplied-polys-filter (var-list products-already-triedadd-multiplied-polys-filter17875,781177
(defun add-multiplied-polys (var-list products-already-triedadd-multiplied-polys17955,784777
(defun deal-with-product1 (part-of-new-var var-listdeal-with-product118039,788286
(defun deal-with-product (new-var pot-lst-to-look-indeal-with-product18158,793972
(defun deal-with-factor (new-var pot-lst-to-look-indeal-with-factor18204,795866
(defun deal-with-division (new-var inverse-vardeal-with-division18292,799972
(defun non-linear-arithmetic1 (new-vars pot-lst ;;; to look-in/step-downnon-linear-arithmetic118409,805103
(defun non-linear-arithmetic (new-vars pot-lst ;;; to look-in/step-downnon-linear-arithmetic18502,809449
(defun add-polys-and-lemmas2-nl (new-vars old-pot-lst ; &extra formalsadd-polys-and-lemmas2-nl18791,821031
(defun add-polys-and-lemmas1-nl (old-pot-lst cnt ; &extra formalsadd-polys-and-lemmas1-nl18884,825241
(defun add-polys-and-lemmas1 (new-vars old-pot-lst ; &extra formalsadd-polys-and-lemmas119008,830484
(defun add-polys-and-lemmas (lst disjunctsp ; &extra formalsadd-polys-and-lemmas19074,833196
(defun add-disjunct-polys-and-lemmas (lst1 lst2 ; &extra formalsadd-disjunct-polys-and-lemmas19171,837270
(defun add-disjuncts-polys-and-lemmas (split-lst to-do-lateradd-disjuncts-polys-and-lemmas19285,842402
(defun add-terms-and-lemmas (term-lst ttrees positivepadd-terms-and-lemmas19457,850502
(defun rewrite-with-linear (term ; &extra formalsrewrite-with-linear19552,854858

simplify.lisp,19196
(defun negate-lit (term type-alist ens force-flg wrld)negate-lit65,2819
(defun pegate-lit (term type-alist ens force-flg wrld)pegate-lit86,3645
(defun add-literal (lit cl at-end-flg)add-literal107,4440
(defun add-each-literal (cl)add-each-literal144,5860
(defun subsumes-rec (count cl1 cl2 alist)subsumes-rec206,8828
(defun subsumes1-equality-with-const (count lit x const1 tl1 tl2 cl2 alist)subsumes1-equality-with-const252,11316
(defun subsumes1 (count lit tl1 tl2 cl2 alist)subsumes1301,14150
(defun subsumes!-rec (cl1 cl2 alist)subsumes!-rec336,15656
(defun subsumes!1-equality-with-const (lit x const1 tl1 tl2 cl2 alist)subsumes!1-equality-with-const363,16943
(defun subsumes!1 (lit tl1 tl2 cl2 alist)subsumes!1399,18696
(defconst *init-subsumes-count**init-subsumes-count*419,19397
(defun subsumes (init-subsumes-count cl1 cl2 alist)subsumes439,20215
(defun some-member-subsumes (init-subsumes-count cl-set cl acc)some-member-subsumes462,21200
(defun conjoin-clause-to-clause-set (cl cl-set)conjoin-clause-to-clause-set475,21722
(defun add-each-literal-lst (cl-set)add-each-literal-lst494,22646
(defun conjoin-clause-sets (cl-set1 cl-set2)conjoin-clause-sets500,22849
(defun some-element-member-complement-term (lst1 lst2)some-element-member-complement-term506,23055
(defun disjoin-clauses1 (cl1 cl2)disjoin-clauses1514,23376
(defun disjoin-clauses (cl1 cl2)disjoin-clauses530,24029
(defun disjoin-clause-segment-to-clause-set (segment cl-set)disjoin-clause-segment-to-clause-set548,24640
(defun split-on-assumptions (assumptions cl ans)split-on-assumptions567,25558
(defun rewrite-clause-action (lit branches)rewrite-clause-action581,26033
(defrec forward-chaining-ruleforward-chaining-rule717,33879
(defrec fc-activationfc-activation727,34373
(defun suspend-fc-activation (act inst-hyp hyps unify-subst ttree)suspend-fc-activation840,40932
(defun prettyify-fc-activation (act level)prettyify-fc-activation901,43353
(defun prettyify-fc-activations (acts level)prettyify-fc-activations976,46700
(defun make-fc-activation (term rule ttree ens)make-fc-activation981,46897
(defun make-fc-activations (term rules ttree ens activations)make-fc-activations1029,49411
(defun collect-terms-and-activations (term ttree wrld ens trigger-terms activations)collect-terms-and-activations1039,49820
(defun collect-terms-and-activations-lstcollect-terms-and-activations-lst1092,52378
(defun collect-terms-and-activations-from-fcd-lst (fcd-lst wrld enscollect-terms-and-activations-from-fcd-lst1105,52966
(defun sublis-varp (alist term)sublis-varp1137,54353
(defun sublis-var-lstp (alist l)sublis-var-lstp1146,54638
(defun mult-search-type-alist (rest-hyps concls term typ type-alistmult-search-type-alist1155,54885
(defun mult-lookup-hyp (hyp rest-hyps concls type-alist wrld unify-subst ttreemult-lookup-hyp1226,58673
(defun ev-respecting-ens (form alist state latches ttree ens wrld)ev-respecting-ens1245,59482
(defun ev-lst-respecting-ens (lst alist state latches ttree ens wrld)ev-lst-respecting-ens1302,62400
(defun add-fc-derivations (rune concls unify-subst inst-triggeradd-fc-derivations1401,67961
(defun prettyify-fc-derivation (fcd level)prettyify-fc-derivation1438,69596
(defun prettyify-fc-derivations (fcd-lst level)prettyify-fc-derivations1499,72210
(defun expunge-fc-derivations-lst (fc-derivation-lst ttree)expunge-fc-derivations-lst1507,72441
(defun expunge-fc-derivations (ttree)expunge-fc-derivations1517,72952
(defun current-fc-call-number (data)current-fc-call-number1707,82792
(defun current-fc-call-alist (data)current-fc-call-alist1711,82911
(defun put-current-fc-call-alist (call-alist data)put-current-fc-call-alist1715,83029
(defun initialize-fc-wormhole-sites ()initialize-fc-wormhole-sites1733,83866
(deflabel forward-chaining-reportsforward-chaining-reports1748,84317
(defun show-fc-criteria ()show-fc-criteria2034,97548
(defun reset-fc-reporting ()reset-fc-reporting2057,98085
(defun translate-fc-criterion (x state)translate-fc-criterion2088,98952
(defun translate-fc-criteria (lst state)translate-fc-criteria2119,100167
(defun set-fc-criteria-fn (x state)set-fc-criteria-fn2136,100902
(defmacro set-fc-criteria (&rest x)set-fc-criteria2160,101707
(defun set-fc-report-on-the-fly (flg)set-fc-report-on-the-fly2232,104949
(defun new-fc-call (caller cl pts force-flg do-not-reconsiderp wrld ensnew-fc-call2290,107213
(defun member-one-way-unify1 (term pat-lst unify-subst)member-one-way-unify12336,109245
(defun satisfying-fc-activation1p (criterion act)satisfying-fc-activation1p2350,109693
(defun satisfying-fc-activationp (criteria act)satisfying-fc-activationp2369,110392
(defun collect-satisfying-fc-activations (criteria acts ans)collect-satisfying-fc-activations2374,110600
(defun satisfying-virtual-fc-activation1p (criterion act0 unify-subst)satisfying-virtual-fc-activation1p2392,111530
(defun satisfying-virtual-fc-activationp (criteria act0 unify-subst)satisfying-virtual-fc-activationp2418,112618
(defun satisfying-fc-derivation1p (criterion fcd)satisfying-fc-derivation1p2430,113223
(defun satisfying-fc-derivationp (criteria fcd)satisfying-fc-derivationp2444,113701
(defun collect-satisfying-fc-derivations (criteria fcd-lst ans)collect-satisfying-fc-derivations2449,113909
(defun filter-satisfying-virtual-fc-activation (act0 inst-hyp hyps unify-subst ttree)filter-satisfying-virtual-fc-activation2464,114566
(defun filter-all-satisfying-fc-derivations (fcd-lst)filter-all-satisfying-fc-derivations2517,117086
(defun filter-satisfying-fc-activations (acts)filter-satisfying-fc-activations2562,119083
(defun filter-redundant-approved-fc-derivation (fcd)filter-redundant-approved-fc-derivation2596,120409
(defun collect-rune-trigger-pairs-from-fc-activations (acts ans)collect-rune-trigger-pairs-from-fc-activations2696,124749
(defun collect-rune-trigger-pairs-from-fc-derivations (fcds ans)collect-rune-trigger-pairs-from-fc-derivations2706,125248
(defun prettyify-subst (alist)prettyify-subst2717,125751
(defun collect-fc-status-site-1 (rune inst-trigger acts)collect-fc-status-site-12724,126024
(defun collect-fc-status-sites-2-3-5 (rune inst-trigger all-fcdscollect-fc-status-sites-2-3-52750,127282
(defun prettyify-blocked-fc-inst-hyp (inst-hyp hyps unify-subst)prettyify-blocked-fc-inst-hyp2784,128971
(defun collect-fc-status-site-4 (rune inst-trigger acts)collect-fc-status-site-42803,129775
(defun collect-fc-status (rune inst-trigger site1 site2 site3 site4 site5)collect-fc-status2831,131067
(defun make-fc-activity-report1 (rune-trigger-pairs site1 site2 site3 site4 site5)make-fc-activity-report12843,131585
(defun make-fc-activity-report (call-alist)make-fc-activity-report2855,132166
(defun fc-report1 (whs k)fc-report12881,133210
(defun fc-report (k)fc-report2920,134589
(defun fc-exit (flg type-alist ttree-or-fc-pairsfc-exit2954,135612
(defun advance-fc-activation1advance-fc-activation13072,141659
(defun advance-fc-activation2advance-fc-activation23230,148410
(defun advance-fc-activation3advance-fc-activation33462,158532
(defun advance-fc-activation (act fc-round type-alist ens force-flg wrld state oncep-overrideadvance-fc-activation3486,159501
(defun advance-fc-activations (lst fc-round type-alist ens force-flg wrld state oncep-overrideadvance-fc-activations3511,160540
(defun fc-pair-lst (fcd-lst)fc-pair-lst3532,161578
(defun fc-pair-lst-type-alist (fc-pair-lst fcd-lst type-alist force-flg ens wrld)fc-pair-lst-type-alist3554,162602
(defmacro fcd-runep (rune ttree)fcd-runep3676,168253
(defun fcd-runep-lst (rune lst)fcd-runep-lst3687,168794
(defmacro fcd-worse-than-or-equal (concl fn-cnt p-fn-cnt ttree)fcd-worse-than-or-equal3693,169041
(defun fcd-worse-than-or-equal-lst (concl fn-cnt p-fn-cnt lst)fcd-worse-than-or-equal-lst3705,169640
(defun exists-fcd-worse-than-or-equal (fcd-lst concl fn-cnt p-fn-cnt)exists-fcd-worse-than-or-equal3741,171456
(defun all-dumb-occur-lst (args cl)all-dumb-occur-lst3757,172181
(defun all-args-occur-after-strip-not (term cl)all-args-occur-after-strip-not3762,172344
(defun approved-fc-derivationp (fcd cl)approved-fc-derivationp3778,173038
(defun approve-fc-derivations (new-fcd-lst cl approved-this-round all-approved)approve-fc-derivations3864,176138
(defun max-level-no (term wrld)max-level-no3892,177536
(defun max-level-no-lst (args wrld)max-level-no-lst3907,178175
(defun get-level-no (fn wrld)get-level-no3912,178338
(defun sort-approved1-rating1 (term wrld fc vc)sort-approved1-rating13926,178638
(defun sort-approved1-rating1-lst (lst wrld fc vc)sort-approved1-rating1-lst3944,179487
(defun sort-approved1-rating (term wrld)sort-approved1-rating3951,179738
(defun sort-approved1 (approved wrld)sort-approved13969,180665
(defun sort-approved (approved wrld)sort-approved3978,180968
(defun strip-fcd-concls (fcd-lst)strip-fcd-concls3985,181225
(defun type-alist-fcd-lst (fcd-lst type-alisttype-alist-fcd-lst3993,181502
(defun every-concl-member-equalp (fcd-lst trigger-terms)every-concl-member-equalp4043,183741
(defun forward-chain1 (cl fc-round trigger-terms activations type-alist force-flg wrldforward-chain14057,184252
(defun forward-chain-top (caller cl pts force-flg do-not-reconsiderp wrld ensforward-chain-top4135,188551
(defun forward-chain (cl pts force-flg do-not-reconsiderp wrld ensforward-chain4240,193567
(defun select-forward-chained-concls-and-ttrees (fc-pair-lst pt lits ttree-lst)select-forward-chained-concls-and-ttrees4258,194442
(defun rewrite-clause-type-alist (tail new-clause fc-pair-lst rcnst wrldrewrite-clause-type-alist4532,207276
(defun maximal-multiples1 (term-lst new-vars avoid-vars pkg-witness)maximal-multiples14836,221859
(defun maximal-multiples (term pkg-witness)maximal-multiples4850,222355
(defun lambda-abstract1 (vars terms)lambda-abstract14863,222790
(defun lambda-abstract (term pkg-witness)lambda-abstract4872,223141
(defun mutually-exclusive-tests (a b)mutually-exclusive-tests4889,223660
(defun mutually-exclusive-subsumptionp (a b c)mutually-exclusive-subsumptionp4920,224777
(defun cleanup-if-expr (x trues falses)cleanup-if-expr4940,225471
(defun cleanup-if-expr-lst (x trues falses)cleanup-if-expr-lst4964,226383
(defun all-type-reasoning-tags-p1 (lemmas)all-type-reasoning-tags-p14970,226573
(defun all-type-reasoning-tags-p (ttree)all-type-reasoning-tags-p4977,226831
(defun try-clause (atm clause wrld)try-clause4980,226935
(defconst *trivial-non-nil-ttree**trivial-non-nil-ttree*4995,227362
(defun make-non-nil-ttree (ttree)make-non-nil-ttree4998,227414
(defun try-type-set-and-clause (atm ans ttree ttree0 current-clause wrld enstry-type-set-and-clause5002,227493
(defun lambda-subtermp (term)lambda-subtermp5033,228923
(defun lambda-subtermp-lst (termlist)lambda-subtermp-lst5043,229177
(defun rewrite-atm (atm not-flg bkptr gstack type-alist wrldrewrite-atm5051,229335
(defun every-occurrence-equiv-hittablep1every-occurrence-equiv-hittablep15432,246164
(defun every-occurrence-equiv-hittablep1-listpevery-occurrence-equiv-hittablep1-listp5471,247512
(defun every-occurrence-equiv-hittablep (equiv old geneqv term ens wrld)every-occurrence-equiv-hittablep5489,248007
(defun every-occurrence-equiv-hittablep-in-clausep (equiv old cl ens wrld)every-occurrence-equiv-hittablep-in-clausep5510,248867
(defun some-occurrence-equiv-hittablep1 (equiv old geneqv term ens wrld)some-occurrence-equiv-hittablep15532,249623
(defun some-occurrence-equiv-hittablep1-listpsome-occurrence-equiv-hittablep1-listp5564,250702
(defun some-occurrence-equiv-hittablep (equiv old geneqv term ens wrld)some-occurrence-equiv-hittablep5580,251133
(defun equiv-hittable-in-some-other-lit (equiv term n cl i ens wrld)equiv-hittable-in-some-other-lit5597,251740
(defun find-trivial-equivalence1find-trivial-equivalence15610,252296
(defun find-trivial-equivalence (not-just-quotep-flg cl ens wrld avoid-lst)find-trivial-equivalence5766,260335
(defun add-literal-and-pt1 (cl-tail pt cl pt-lst)add-literal-and-pt15817,262821
(defun add-literal-and-pt (lit pt cl pt-lst ttree)add-literal-and-pt5835,263637
(defun add-binding-to-tag-tree (var term ttree)add-binding-to-tag-tree5866,264771
(defun subst-equiv-and-maybe-delete-litsubst-equiv-and-maybe-delete-lit5880,265299
(defun remove-trivial-equivalencesremove-trivial-equivalences5935,268048
(defrec built-in-clause ((nume . all-fnnames) clause . rune) t)built-in-clause6006,271892
(defconst *initial-built-in-clauses**initial-built-in-clauses*6019,272604
(defun built-in-clausep2 (bic-lst cl fns ens)built-in-clausep26247,281121
(defun built-in-clausep1 (bic-alist cl fns ens)built-in-clausep16260,281711
(defun possible-trivial-clause-p (cl)possible-trivial-clause-p6283,282851
(defun trivial-clause-p (cl wrld)trivial-clause-p6307,283780
(defun built-in-clausep (caller cl ens match-free-override wrld state)built-in-clausep6312,283930
(defun crunch-clause-segments1 (seg1 pts1 cl pts)crunch-clause-segments16385,287747
(defun crunch-clause-segments2 (cl pts seg1 pts1)crunch-clause-segments26425,289938
(defun crunch-clause-segments (seg1 pts1 seg2 ens wrld state ttree)crunch-clause-segments6439,290449
(defun strip-non-rewrittenp-assumptions1 (recs acc)strip-non-rewrittenp-assumptions16506,294109
(defun strip-non-rewrittenp-assumptions (ttree)strip-non-rewrittenp-assumptions6521,294816
(defun assumnote-list-to-token-list (assumnote-list)assumnote-list-to-token-list6538,295548
(defun resume-suspended-assumption-rewriting1resume-suspended-assumption-rewriting16544,295761
(defun resume-suspended-assumption-rewritingresume-suspended-assumption-rewriting6702,303689
(defun helpful-little-ecnt-msg (case-limit ecnt)helpful-little-ecnt-msg6797,308838
(defun rewrite-clause (tail pts bkptr gstack new-clause fc-pair-lst wrldrewrite-clause6811,309213
(defun rewrite-clause-lst (segs bkptr gstack cdr-tail cdr-pts new-clauserewrite-clause-lst7169,326436
(defun setup-simplify-clause-pot-lst1 (cl ttrees type-alist rcnst wrld statesetup-simplify-clause-pot-lst17237,329276
(defun setup-simplify-clause-pot-lst (cl ttrees fc-pair-lstsetup-simplify-clause-pot-lst7270,330611
(defun sequential-subst-var-term (alist term)sequential-subst-var-term7357,333898
(defun process-equational-polysprocess-equational-polys7369,334364
(defun enumerate-elements (lst i)enumerate-elements7548,342989
(defun already-used-by-fertilize-clausep (lit hist get-clause-id)already-used-by-fertilize-clausep7552,343110
(defun unhidden-lit-info (hist clause pos wrld)unhidden-lit-info7569,343969
(defun tilde-@-hyp-phrase (len-tail cl)tilde-@-hyp-phrase7588,344821
(defun simplify-clause1 (top-clause hist rcnst wrld state step-limit)simplify-clause17617,345931
(defun some-element-dumb-occur-lst (lst1 lst2)some-element-dumb-occur-lst7795,354551
(defrec prove-spec-varprove-spec-var7808,355121
(defrec gag-infogag-info7835,356297
(defrec gag-stategag-state7851,356859
(defconst *initial-gag-state**initial-gag-state*7859,357255
(defconst *empty-prove-spec-var**empty-prove-spec-var*7867,357428
(defun controller-unify-subst2 (vars acc)controller-unify-subst27882,357830
(defun controller-unify-subst1 (actuals controllers acc)controller-unify-subst17889,358069
(defun controller-unify-subst (name term def-body)controller-unify-subst7897,358402
(defun filter-disabled-expand-terms (terms ens wrld)filter-disabled-expand-terms7904,358703
(defun found-hit-rewrite-hist-entry (hist)found-hit-rewrite-hist-entry7985,362752
(defabbrev append? (x y)append?7999,363321
(defun simplify-clause (cl hist pspv wrld state step-limit)simplify-clause8003,363395
(defun settled-down-clause (clause hist pspv wrld state)settled-down-clause8357,381955
(defun member-class-name-runes (class name runes)member-class-name-runes8380,382927
(defun extract-and-classify-lemmas2 (names class ignore-lst if-intro case-splitextract-and-classify-lemmas28388,383200
(defun extract-and-classify-lemmas1 (class-alist ignore-lst if-intro case-splitextract-and-classify-lemmas18413,384498
(defun runes-to-class-alist1 (runes alist)runes-to-class-alist18430,385265
(defun strict-merge-symbol-< (l1 l2 acc)strict-merge-symbol-<8444,385897
(defun strict-merge-sort-symbol-< (l)strict-merge-sort-symbol-<8465,386730
(defun strict-symbol-<-sortedp (x)strict-symbol-<-sortedp8482,387241
(defun sort-symbol-listp (x)sort-symbol-listp8489,387469
(defun strict-merge-sort-symbol-<-cdrs (alist)strict-merge-sort-symbol-<-cdrs8495,387637
(defun runes-to-class-alist (runes)runes-to-class-alist8501,387871
(defun extract-and-classify-lemmas (ttree ignore-lst forced-runes)extract-and-classify-lemmas8508,388063
(deflabel SimpleSimple8540,389455
(defun tilde-*-conjunction-of-possibly-forced-names-phrase1 (alist)tilde-*-conjunction-of-possibly-forced-names-phrase18573,390850
(defun tilde-*-conjunction-of-possibly-forced-names-phrase (lst)tilde-*-conjunction-of-possibly-forced-names-phrase8587,391398
(defconst *fake-rune-alist**fake-rune-alist*8602,392001
(defun rune-< (x y)rune-<8615,392464
(defun merge-runes (l1 l2)merge-runes8630,392822
(defun merge-sort-runes (l)merge-sort-runes8637,393040
(defun tilde-*-simp-phrase1 (alist abbreviations-flg)tilde-*-simp-phrase18642,393205
(defun tilde-*-raw-simp-phrase1 (runes forced-runes punct ignore-lst phrasetilde-*-raw-simp-phrase18772,398347
(defun recover-forced-runes1 (recs ans)recover-forced-runes18821,400637
(defun recover-forced-runes (ttree)recover-forced-runes8833,401014
(defun tilde-*-raw-simp-phrase (ttree punct phrase)tilde-*-raw-simp-phrase8845,401555
(defun tilde-*-simp-phrase (ttree)tilde-*-simp-phrase8872,402507
(defun tilde-@-pool-name-phrase (forcing-round pool-lst)tilde-@-pool-name-phrase8904,403928
(defun tilde-@-pool-name-phrase-lst (forcing-round lst)tilde-@-pool-name-phrase-lst8942,405866
(defun tilde-@-clause-id-phrase (id)tilde-@-clause-id-phrase8947,406092
(defrec bddnotebddnote9036,409059
(defun tilde-@-bddnote-phrase (x)tilde-@-bddnote-phrase9040,409160
(defun parse-natural1 (str i maximum ans)parse-natural19054,409673
(defun parse-natural (dflg str i maximum)parse-natural9080,410625
(defun parse-dotted-naturals (dflg str i maximum ans)parse-dotted-naturals9101,411431
(defun parse-match (pat j patmax str i strmax)parse-match9137,413109
(defun parse-primes (str i maximum)parse-primes9151,413672
(defun parse-clause-id2 (forcing-round pool-lst str i maximum)parse-clause-id29177,414655
(defun parse-clause-id1 (forcing-round str i maximum)parse-clause-id19207,415667
(defun parse-clause-id (str)parse-clause-id9272,417946
(defun tilde-@-case-split-limitations-phrase (sr-flg case-flg prefix)tilde-@-case-split-limitations-phrase9310,419249
(defun simplify-clause-msg1 (signal cl-id clauses speciousp ttree pspv state)simplify-clause-msg19325,419791
(deflabel specious-simplificationspecious-simplification9447,426022
(defun settled-down-clause-msg1 (signal clauses ttree pspv state)settled-down-clause-msg19559,431610

bdd.lisp,8083
(defmacro mvf (x &rest rest)mvf45,1569
(defmacro logandf (&rest args)logandf57,2133
(defmacro logxorf (&rest args)logxorf60,2201
(defmacro logiorf (&rest args)logiorf63,2268
(defmacro ashf (x y)ashf66,2335
(defmacro mx-id-bound ()mx-id-bound70,2441
(defmacro 1+mx-id (x)1+mx-id78,2692
(defmacro bdd-error (mx-id fmt-string fmt-alist bad-cst ttree)bdd-error125,4696
(defmacro unique-id (x) `(the-fixnum (car ,x)))unique-id207,8076
(defmacro tst (x) `(cadr ,x)) ;a cst, not a number; but beware since tst=trmtst209,8125
(defmacro cst-boolp (x) `(caddr ,x))cst-boolp215,8415
(defmacro tbr (x) `(cadddr ,x))tbr217,8453
(defmacro fbr (x) `(cddddr ,x))fbr218,8485
(defmacro leafp (x)leafp220,8518
(defmacro trm (x) `(cadr ,x))trm223,8561
(defun bdd-constructors (wrld)bdd-constructors225,8592
(defun make-leaf-cst (unique-id trm boolp)make-leaf-cst235,8944
(defun evg-fn-symb (x)evg-fn-symb245,9246
(defun bdd-constructor-trm-p (trm bdd-constructors)bdd-constructor-trm-p274,10233
(defun evg-type (x)evg-type280,10446
(defun make-if-cst (unique-id tst tbr fbr bdd-constructors)make-if-cst296,10986
(defconst *cst-t*   (make-leaf-cst 1 *t* t))*cst-t*355,13913
(defconst *cst-nil* (make-leaf-cst 2 *nil* t))*cst-nil*356,13958
(defmacro cst= (cst1 cst2)cst=358,14006
(defmacro cst-tp (cst)cst-tp362,14084
(defmacro cst-nilp (cst)cst-nilp365,14135
(defmacro cst-varp (cst)cst-varp368,14188
(defun cst-nonnilp (cst)cst-nonnilp371,14241
(defun bool-mask1 (formals vars rune)bool-mask1395,15298
(defun boolean-term-var (x)boolean-term-var412,16118
(defun boolean-hyps-vars (hyps)boolean-hyps-vars445,17302
(defun first-boolean-type-prescription (type-prescription-list ens formals)first-boolean-type-prescription460,17682
(defun recognizer-rune (fn recognizer-alist wrld ens)recognizer-rune495,19293
(defun bool-mask (fn recognizer-alist wrld ens)bool-mask505,19719
(defun commutative-p1 (fn lemmas ens)commutative-p1549,21308
(defun find-equivalence-rune (fn rules)find-equivalence-rune578,22704
(defun equivalence-rune1 (fn congruences)equivalence-rune1589,23057
(defun equivalence-rune (fn wrld)equivalence-rune616,24053
(defun commutative-p (fn ens wrld)commutative-p626,24424
(defun op-alist (fns acc i ens wrld)op-alist643,25062
(defun op-alist-info (fn op-alist)op-alist-info679,26597
(defmacro if-op-code () 3)if-op-code702,27209
(defmacro hash-size ()hash-size704,27237
(defmacro if-hash-index (x y z)if-hash-index731,28315
(defun op-hash-index1 (args i acc)op-hash-index1743,28736
(defmacro op-hash-index (op-code args)op-hash-index770,29783
(defmacro op-hash-index-2 (op-code arg1 arg2)op-hash-index-2775,29918
(defmacro op-hash-index-if (arg1 arg2 arg3)op-hash-index-if785,30189
(defun if-search-bucket (x y z lst)if-search-bucket795,30500
(defun cst=-lst (x y)cst=-lst806,30790
(defmacro eq-op (x y)eq-op812,30913
(defun op-search-bucket (op args lst)op-search-bucket818,31020
(defun op-search-bucket-2 (op arg1 arg2 lst)op-search-bucket-2831,31499
(defun op-search-bucket-if (arg1 arg2 arg3 lst)op-search-bucket-if848,32233
(defun chk-memo (op-code op args op-ht)chk-memo864,32847
(defun chk-memo-2 (op-code op arg1 arg2 op-ht)chk-memo-2882,33516
(defun chk-memo-if (arg1 arg2 arg3 op-ht)chk-memo-if898,34050
(defmacro half-hash-size ()half-hash-size918,34764
(defmacro fourth-hash-size ()fourth-hash-size921,34818
(defun op-hash-index-string (index acc string)op-hash-index-string924,34874
(defun op-hash-index-evg (evg)op-hash-index-evg937,35270
(defun op-search-bucket-quote (evg bucket)op-search-bucket-quote970,36309
(defun chk-memo-quotep (term op-ht)chk-memo-quotep978,36584
(defun bdd-quotep (term op-ht mx-id)bdd-quotep994,37068
(defmacro bdd-quotep+ (term op-ht if-ht mx-id ttree)bdd-quotep+1027,38179
(defrec bdd-rulebdd-rule1044,38998
(defun rewrite-rule-to-bdd-rule (lemma)rewrite-rule-to-bdd-rule1048,39040
(defun bdd-rules-alist1bdd-rules-alist11054,39242
(defun extra-rules-for-bdds (fn wrld)extra-rules-for-bdds1132,43377
(defun bdd-rules-alist (fns all-fns bdd-rules-alist ens wrld)bdd-rules-alist1199,46029
(defmacro one-way-unify1-cst-2 (mx-id p1 p2 cst1 cst2 alist op-ht)one-way-unify1-cst-21261,48649
(defmacro one-way-unify1-cst-3 (mx-id p1 p2 p3 cst1 cst2 cst3 alist op-ht)one-way-unify1-cst-31275,49267
(defun one-way-unify1-cst (mx-id pat cst alist op-ht)one-way-unify1-cst1293,49997
(defun one-way-unify1-cst-lst (mx-id pl cstl alist op-ht)one-way-unify1-cst-lst1474,60842
(defun one-way-unify1-cst-equal (mx-id pat1 pat2 cst1 cst2 alist op-ht)one-way-unify1-cst-equal1492,61495
(defun some-one-way-unify-cst-lst (cst-lst rules op-ht mx-id ttree)some-one-way-unify-cst-lst1506,61984
(defun leaf-cst-list (lst bool-vars acc mx-id)leaf-cst-list1535,63135
(defun decode-cst (cst cst-array)decode-cst1557,63988
(defun decode-cst-lst (cst-lst cst-array)decode-cst-lst1595,65259
(defun decode-cst-alist1 (alist cst-array)decode-cst-alist11607,65626
(defun decode-cst-alist (cst-alist cst-array)decode-cst-alist1619,66074
(defun leaf-cst-list-array (mx-id)leaf-cst-list-array1625,66256
(defconst *some-non-nil-value* "Some non-nil value")*some-non-nil-value*1632,66487
(defun falsifying-assignment1 (cst acc cst-array)falsifying-assignment11634,66541
(defun falsifying-assignment (cst mx-id)falsifying-assignment1671,67928
(defun make-if (mx-id n op args x y z op-ht if-ht bdd-constructors)make-if1681,68289
(defun make-if-no-memo (mx-id x y z op-ht if-ht bdd-constructors)make-if-no-memo1760,71876
(defmacro split-var (cst)split-var1794,73155
(defun min-var (acc args)min-var1807,73494
(defun combine-op-csts1 (var-id args)combine-op-csts11827,74082
(defun bool-flg (args mask)bool-flg1860,75605
(defun some-bdd-constructorp (args bdd-constructors)some-bdd-constructorp1882,76256
(defun combine-op-csts-simplecombine-op-csts-simple1889,76513
(defmacro bdd-mv-let (vars form body)bdd-mv-let1941,78444
(defmacro combine-if-csts+ (cst1 cst2 cst3 op-ht if-ht mx-id bdd-constructors)combine-if-csts+2004,80869
(defun combine-if-csts1 (var-id args)combine-if-csts12013,81192
(defun combine-if-cstscombine-if-csts2033,81917
(defun cst-list-to-evg-list (cst-lst)cst-list-to-evg-list2111,85081
(defun cst-quote-listp (cst-lst)cst-quote-listp2117,85244
(defrec bddspvbddspv2125,85428
(defun bdd-ev-fncallbdd-ev-fncall2136,85831
(defmacro combine-op-csts+ (mx-id comm-p enabled-exec-p op-code op mask args op-htcombine-op-csts+2166,87051
(defun make-if-for-opmake-if-for-op2184,87998
(defun combine-op-csts (mx-id enabled-exec-p op-code op mask args op-htcombine-op-csts2234,89514
(defun combine-op-csts-comm (mx-id comm-p enabled-exec-p op-code op mask arg1combine-op-csts-comm2264,90648
(defun combine-op-csts-gutscombine-op-csts-guts2341,93875
(defun bdd (term alist op-ht if-ht mx-id ttree bddspv state)bdd2462,99048
(defun bdd-alist (formals actuals alist op-ht if-ht mx-id ttree bddspv state)bdd-alist2583,103825
(defun bdd-list (lst alist op-ht if-ht mx-id ttree bddspv state)bdd-list2602,104549
(defun if-ht-max-length (state)if-ht-max-length2629,105483
(defun op-ht-max-length (state)op-ht-max-length2634,105638
(defun leaf-cst-list-to-alist (leaf-cst-list)leaf-cst-list-to-alist2639,105793
(defvar *request-bigger-fixnum-table**request-bigger-fixnum-table*2653,106221
(defun bdd-top (term input-vars bool-vars bdd-constructors cl-id ens state)bdd-top2656,106311
(defun get-bool-vars (vars type-alist ttree acc)get-bool-vars2764,111984
(defun bdd-clause1 (hint-alist type-alist cl position ttree0 cl-id ens wrldbdd-clause12782,112589
(defmacro expand-and-or-simple+expand-and-or-simple+2908,118017
(defun expand-and-or-simpleexpand-and-or-simple2920,118482
(defun expand-clauseexpand-clause3067,124978
(defun bdd-clause (bdd-hint cl-id top-clause pspv wrld state)bdd-clause3092,125980
(deflabel obddobdd3208,131943
(deflabel bdd-algorithmbdd-algorithm3216,132097
(deflabel bdd-introductionbdd-introduction3726,157290

other-processes.lisp,6751
(defun strip-final-digits1 (lst)strip-final-digits130,1253
(defun strip-final-digits (str)strip-final-digits51,2117
(defconst *var-families-by-type**var-families-by-type*76,3315
(defun assoc-ts-subsetp (ts alist)assoc-ts-subsetp97,4014
(defun first-non-member-eq (lst1 lst2)first-non-member-eq107,4281
(defun abbreviate-hyphenated-string1 (str i maximum prev-c)abbreviate-hyphenated-string1120,4689
(defun abbreviate-hyphenated-string (str)abbreviate-hyphenated-string147,5788
(defun generate-variable-root1 (term avoid-lst type-alist ens wrld)generate-variable-root1164,6375
(defun generate-variable-root (term avoid-lst type-alist ens wrld)generate-variable-root225,8865
(defun generate-variable (term avoid-lst type-alist ens wrld)generate-variable244,9569
(defun generate-variable-lst (term-lst avoid-lst type-alist ens wrld)generate-variable-lst256,10121
(defrec elim-ruleelim-rule290,11827
(defun occurs-nowhere-else (var args c i)occurs-nowhere-else296,11965
(defun first-nomination (term votes nominations)first-nomination308,12364
(defun second-nomination (term votes nominations)second-nomination315,12532
(defun some-hyp-probably-nilp (hyps type-alist ens wrld)some-hyp-probably-nilp328,12953
(defun sublis-expr (alist term)sublis-expr354,13821
(defun sublis-expr-lst (alist lst)sublis-expr-lst372,14513
(defun nominate-destructor-candidatenominate-destructor-candidate379,14679
(defun nominate-destructor-candidatesnominate-destructor-candidates504,21176
(defun nominate-destructor-candidates-lstnominate-destructor-candidates-lst527,22004
(defun sum-level-nos (lst wrld)sum-level-nos554,23112
(defun pick-highest-sum-level-nos (nominations wrld dterm max-score)pick-highest-sum-level-nos570,23777
(defun select-instantiated-elim-rule (clause type-alist eliminables ens wrld)select-instantiated-elim-rule589,24561
(defun type-restriction-segment (cl terms vars type-alist ens wrld)type-restriction-segment640,27174
(defun subterm-one-way-unify (pat term)subterm-one-way-unify736,31670
(defun subterm-one-way-unify-lst (pat-lst term)subterm-one-way-unify-lst749,32208
(defrec generalize-rule (nume formula . rune) nil)generalize-rule759,32501
(defun apply-generalize-rule (gen-rule term ens)apply-generalize-rule761,32553
(defun generalize-rule-segment1 (generalize-rules term ens)generalize-rule-segment1800,34317
(defun generalize-rule-segment (terms vars ens wrld)generalize-rule-segment822,35419
(defun generalize1 (cl type-alist terms vars ens wrld)generalize1846,36598
(defun apply-instantiated-elim-rule (rule cl type-alist avoid-vars ens wrld)apply-instantiated-elim-rule879,38225
(defun eliminate-destructors-clause1 (cl eliminables avoid-vars ens wrldeliminate-destructors-clause1995,44107
(defun owned-vars (process mine-flg history)owned-vars1140,51274
(defun eliminate-destructors-clause (clause hist pspv wrld state)eliminate-destructors-clause1219,55508
(defun prettyify-clause1 (cl wrld)prettyify-clause11253,57158
(defun prettyify-clause2 (cl wrld)prettyify-clause21258,57344
(defun prettyify-clause (cl let*-abstractionp wrld)prettyify-clause1272,57954
(defun prettyify-clause-lst (clauses let*-abstractionp wrld)prettyify-clause-lst1285,58505
(defun prettyify-clause-set (clauses let*-abstractionp wrld)prettyify-clause-set1291,58789
(defun tilde-*-elim-phrase/alist1 (alist wrld)tilde-*-elim-phrase/alist11297,59054
(defun tilde-*-elim-phrase/alist (alist wrld)tilde-*-elim-phrase/alist1304,59325
(defun tilde-*-elim-phrase3 (var-to-runes-alist)tilde-*-elim-phrase31316,59769
(defun tilde-*-elim-phrase2 (alist restricted-vars var-to-runes-alist ttree wrld)tilde-*-elim-phrase21324,60172
(defun tilde-*-elim-phrase1 (lst i already-used wrld)tilde-*-elim-phrase11351,61496
(defun tilde-*-elim-phrase (lst wrld)tilde-*-elim-phrase1384,63126
(defun tilde-*-untranslate-lst-phrase (lst flg wrld)tilde-*-untranslate-lst-phrase1404,63744
(defun eliminate-destructors-clause-msg1 (signal clauses ttree pspv state)eliminate-destructors-clause-msg11409,63890
(defun almost-quotep1 (term)almost-quotep11462,66324
(defun almost-quotep1-listp (terms)almost-quotep1-listp1473,66697
(defun almost-quotep (term)almost-quotep1480,66862
(defun destructor-applied-to-varsp (term ens wrld)destructor-applied-to-varsp1492,67217
(defun dumb-occur-lst-except (term lst lit)dumb-occur-lst-except1509,67900
(defun fertilize-feasible (lit cl hist term ens wrld)fertilize-feasible1527,68709
(defun fertilize-complexity (term wrld)fertilize-complexity1545,69499
(defun maximize-fertilize-complexity (terms wrld)maximize-fertilize-complexity1555,69834
(defun first-fertilize-lit (lst cl hist ens wrld)first-fertilize-lit1562,70038
(defun cross-fertilizep/c (equiv cl direction lhs1 rhs1)cross-fertilizep/c1596,71602
(defun cross-fertilizep/d (equiv cl direction lhs1 rhs1)cross-fertilizep/d1610,72093
(defun cross-fertilizep (equiv cl pspv direction lhs1 rhs1)cross-fertilizep1624,72584
(defun delete-from-ttree (tag val ttree)delete-from-ttree1649,73901
(defun fertilize-clause1 (cl lit1 equiv lhs1 rhs1fertilize-clause11661,74427
(defun fertilize-clause (cl-id cl hist pspv wrld state)fertilize-clause1865,84067
(defun fertilize-clause-msg1 (signal clauses ttree pspv state)fertilize-clause-msg11953,88534
(defun collectable-fnp (fn ens wrld)collectable-fnp1998,90495
(defun smallest-common-subterms1 (term1 term2 ens wrld ans)smallest-common-subterms12016,91124
(defun smallest-common-subterms1-lst (terms term2 ens wrld ans)smallest-common-subterms1-lst2077,93556
(defun dumb-fn-count-1 (flg x acc)dumb-fn-count-12098,94237
(defun dumb-fn-count (x)dumb-fn-count2112,94766
(defun smallest-common-subterms (term1 term2 ens wrld ans)smallest-common-subterms2135,95655
(defun generalizing-relationp (term wrld)generalizing-relationp2151,96368
(defun generalizable-terms-across-relations (cl ens wrld ans)generalizable-terms-across-relations2182,97735
(defun generalizable-terms-across-literals1 (lit1 cl ens wrld ans)generalizable-terms-across-literals12197,98356
(defun generalizable-terms-across-literals (cl ens wrld ans)generalizable-terms-across-literals2203,98602
(defun generalizable-terms (cl ens wrld)generalizable-terms2215,99081
(defun generalize-clause (cl hist pspv wrld state)generalize-clause2226,99435
(defun tilde-*-gen-phrase/alist1 (alist wrld)tilde-*-gen-phrase/alist12307,103268
(defun tilde-*-gen-phrase/alist (alist wrld)tilde-*-gen-phrase/alist2314,103537
(defun tilde-*-gen-phrase (alist restricted-vars var-to-runes-alist ttree wrld)tilde-*-gen-phrase2322,103706
(defun generalize-clause-msg1 (signal clauses ttree pspv state)generalize-clause-msg12376,106558

induct.lisp,9977
(defun select-x-cl-set (cl-set induct-hint-val)select-x-cl-set23,881
(defun unchangeables (formals args quick-block-info subset ans)unchangeables35,1336
(defun changeables (formals args quick-block-info subset ans)changeables50,1930
(defun sound-induction-principle-mask1 (formals args quick-block-infosound-induction-principle-mask166,2516
(defun sound-induction-principle-mask (term formals quick-block-info subset)sound-induction-principle-mask104,4307
(defrec candidatecandidate162,7269
(defun count-non-nils (lst)count-non-nils209,10209
(defun controllers (formals args subset ans)controllers214,10354
(defun changed/unchanged-vars (x args mask ans)changed/unchanged-vars221,10637
(defrec tests-and-alists (tests alists) nil)tests-and-alists228,10925
(defun tests-and-alists/alist (alist args mask call-args)tests-and-alists/alist230,10971
(defun tests-and-alists/alists (alist args mask calls)tests-and-alists/alists257,12146
(defrec tests-and-calls (tests . calls) nil)tests-and-calls279,13169
(defrec justificationjustification294,14018
(defun tests-and-alists (alist args mask tc)tests-and-alists299,14132
(defun tests-and-alists-lst (alist args mask machine)tests-and-alists-lst315,14877
(defun flesh-out-induction-principle (term formals justification mask machineflesh-out-induction-principle327,15346
(defun intrinsic-suggested-induction-candintrinsic-suggested-induction-cand364,16488
(defrec induction-rule (nume (pattern . condition) scheme . rune) nil)induction-rule404,18660
(defun apply-induction-rule (rule term type-alist xterm ttree seen ens wrld)apply-induction-rule408,18751
(defun suggested-induction-cands1suggested-induction-cands1518,22845
(defun suggested-induction-candssuggested-induction-cands577,25248
(defun get-induction-cands (term type-alist ens wrld ans)get-induction-cands601,26255
(defun get-induction-cands-lst (lst type-alist ens wrld ans)get-induction-cands-lst617,26774
(defun get-induction-cands-from-cl-set1 (cl-set ens oncep-override wrld stateget-induction-cands-from-cl-set1632,27150
(defun get-induction-cands-from-cl-set (cl-set pspv wrld state)get-induction-cands-from-cl-set659,28281
(defun pigeon-holep-apply (fn pigeon hole)pigeon-holep-apply694,29800
(defun pigeon-holep (pigeons holes filled-holes fn)pigeon-holep736,31588
(defun pigeon-holep1 (pigeon pigeons lst n holes filled-holes fn)pigeon-holep1755,32410
(defun flush-cand1-down-cand2 (cand1 cand2)flush-cand1-down-cand2776,33110
(defun flush-candidates (cand1 cand2)flush-candidates812,34945
(defun alists-agreep (alist1 alist2 vars)alists-agreep837,36181
(defun irreconcilable-alistsp (alist1 alist2)irreconcilable-alistsp850,36682
(defun affinity (aff alist1 alist2 vars)affinity868,37448
(defun member-affinity (aff alist alist-lst vars)member-affinity881,37921
(defun occur-affinity (aff alist lst vars)occur-affinity890,38209
(defun some-occur-affinity (aff alists lst vars)some-occur-affinity906,38779
(defun all-occur-affinity (aff alists lst vars)all-occur-affinity915,39113
(defun contains-affinity (aff lst vars)contains-affinity924,39446
(defun antagonistic-tests-and-alists-lstp (lst vars)antagonistic-tests-and-alists-lstp937,39933
(defun antagonistic-tests-and-alists-lstsp (lst1 lst2 vars)antagonistic-tests-and-alists-lstsp963,40864
(defun every-alist1-matedp (lst1 lst2 vars)every-alist1-matedp978,41349
(defun merge-alist1-into-alist2 (alist1 alist2 vars)merge-alist1-into-alist2999,42274
(defun merge-alist1-lst-into-alist2 (alist1-lst alist2 vars)merge-alist1-lst-into-alist21020,43207
(defun merge-lst1-into-alist2 (lst1 alist2 vars)merge-lst1-into-alist21034,43679
(defun merge-lst1-into-alist2-lst (lst1 alist2-lst vars)merge-lst1-into-alist2-lst1050,44156
(defun merge-lst1-into-lst2 (lst1 lst2 vars)merge-lst1-into-lst21055,44392
(defun merge-tests-and-alists-lsts (lst1 lst2 vars)merge-tests-and-alists-lsts1065,44803
(defun merge-cand1-into-cand2 (cand1 cand2)merge-cand1-into-cand21146,49374
(defun merge-candidates (cand1 cand2)merge-candidates1244,54737
(defun controller-variables1 (args controller-pocket)controller-variables11259,55207
(defun controller-variables (term controller-alist)controller-variables1274,55837
(defun induct-vars1 (lst wrld)induct-vars11288,56542
(defun induct-vars (cand wrld)induct-vars1302,56966
(defun vetoedp (cand vars lst changed-vars-flg)vetoedp1321,57713
(defun compute-vetoes1 (lst cand-lst wrld)compute-vetoes11345,58716
(defun compute-vetoes2 (lst cand-lst)compute-vetoes21367,59557
(defun compute-vetoes (cand-lst wrld)compute-vetoes1383,60108
(defun induction-complexity1 (lst wrld)induction-complexity11447,63447
(defun maximal-elements-apply (fn x wrld)maximal-elements-apply1465,64260
(defun maximal-elements1 (lst winners maximum fn wrld)maximal-elements11478,64700
(defun maximal-elements (lst fn wrld)maximal-elements1503,65735
(defun intersectp-eq/union-equal (x y)intersectp-eq/union-equal1527,66628
(defun equal/union-equal (x y)equal/union-equal1533,66816
(defun subsetp-equal/smaller (x y)subsetp-equal/smaller1539,66969
(defun m&m-apply (fn x y)m&m-apply1544,67087
(defun count-off (n lst)count-off1557,67604
(defun m&m-search (x y-lst del fn)m&m-search1565,67810
(defun m&m1 (pairs del ans n fn)m&m11583,68570
(defun m&m (bag fn)m&m1634,70709
(defun cons-subset-tree (x y)cons-subset-tree1719,75214
(defabbrev car-subset-tree (x)car-subset-tree1736,75638
(defabbrev cdr-subset-tree (x)cdr-subset-tree1742,75723
(defun or-subset-trees (tree1 tree2)or-subset-trees1748,75808
(defun m&m-over-powerset1 (st subset stree ans fn)m&m-over-powerset11760,76306
(defun m&m-over-powerset (st fn)m&m-over-powerset1786,77103
(defun all-picks2 (pocket pick ans)all-picks21895,82378
(defun all-picks2r (pocket pick ans)all-picks2r1901,82558
(defun all-picks1 (pocket picks ans rflg)all-picks11907,82747
(defun all-picks (pockets rflg)all-picks1916,83066
(defun dumb-negate-lit-lst-lst (cl-set)dumb-negate-lit-lst-lst1957,85038
(defun induction-hyp-clause-segments2 (alists cl ans)induction-hyp-clause-segments21969,85533
(defun induction-hyp-clause-segments1 (alists cl-set ans)induction-hyp-clause-segments11975,85778
(defun induction-hyp-clause-segments (alists cl-set)induction-hyp-clause-segments1987,86196
(defun induction-formula3 (neg-tests hyp-segments cl ans)induction-formula32023,87958
(defun induction-formula2 (cl cl-set ta-lst ans)induction-formula22066,89723
(defun induction-formula1 (lst cl-set ta-lst ans)induction-formula12095,90969
(defun induction-formula (cl-set ta-lst)induction-formula2111,91721
(defun all-picks-size (cl-set)all-picks-size2183,94929
(defun induction-formula-size1 (hyps-size concl-size ta-lst)induction-formula-size12190,95132
(defun induction-formula-size (cl-set ta-lst)induction-formula-size2206,95866
(defconst *maximum-induct-size* 100)*maximum-induct-size*2221,96462
(defun termify-clause-set (clauses)termify-clause-set2226,96584
(defun inform-simplify3 (alist terms ans)inform-simplify32243,97257
(defun inform-simplify2 (alists terms ans)inform-simplify22252,97576
(defun inform-simplify1 (ta-lst terms ans)inform-simplify12262,97864
(defun inform-simplify (ta-lst terms pspv)inform-simplify2276,98433
(defun all-vars1-lst-lst (lst ans)all-vars1-lst-lst2327,101319
(defun gen-new-name1 (char-lst wrld i)gen-new-name12336,101620
(defun gen-new-name (root wrld)gen-new-name2346,101945
(defun unmeasured-variables3 (vars alist)unmeasured-variables32354,102177
(defun unmeasured-variables2 (vars alists)unmeasured-variables22362,102489
(defun unmeasured-variables1 (vars ta-lst)unmeasured-variables12368,102719
(defun unmeasured-variables (measured-vars cand)unmeasured-variables2377,103131
(defun tilde-@-well-founded-relation-phrase (rel wrld)tilde-@-well-founded-relation-phrase2388,103620
(defun measured-variables (cand wrld)measured-variables2406,104367
(defun induct-msg/continue (pool-lstinduct-msg/continue2416,104756
(defun rec-fnnames (term wrld)rec-fnnames2597,113148
(defun rec-fnnames-lst (lst wrld)rec-fnnames-lst2608,113630
(defun induct-msg/lose (pool-name induct-hint-val state)induct-msg/lose2615,113801
(defun@par load-hint-settings-into-rcnst (hint-settings rcnst cl-id wrld ctxload-hint-settings-into-rcnst2677,116943
(defun update-hint-settings (new-hint-settings old-hint-settings)update-hint-settings2747,120320
(defun@par load-hint-settings-into-pspv (increment-flg hint-settings pspv cl-idload-hint-settings-into-pspv2762,120885
(defun restore-hint-settings-in-pspv (new-pspv old-pspv)restore-hint-settings-in-pspv2795,122351
(defun remove-trivial-clauses (clauses wrld)remove-trivial-clauses2834,124475
(defun non-standard-vector-check (vars accum)non-standard-vector-check2843,124755
(defun merge-ns-check (checks clause accum)merge-ns-check2851,125019
(defun trap-non-standard-vector-aux (cl-set accum-cl checks wrld)trap-non-standard-vector-aux2859,125302
(defun remove-adjacent-duplicates (lst)remove-adjacent-duplicates2873,125997
(defun non-standard-induction-vars (candidate wrld)non-standard-induction-vars2880,126272
(defun trap-non-standard-vector (cl-set candidate accum-cl wrld)trap-non-standard-vector2892,126696
(defun induct (forcing-round pool-lst cl-set hint-settings pspv wrld ctx state)induct2900,127058
(defun pair-vars-with-lits (cl)pair-vars-with-lits3091,135667
(defun ffnnames-subsetp (term lst)ffnnames-subsetp3104,136009
(defun ffnnames-subsetp-listp (terms lst)ffnnames-subsetp-listp3118,136513
(defun probably-not-validp (cl)probably-not-validp3128,136793
(defun irrelevant-lits (alist)irrelevant-lits3161,138369
(defun eliminate-irrelevance-clause (cl hist pspv wrld state)eliminate-irrelevance-clause3173,138852
(defun eliminate-irrelevance-clause-msg1 (signal clauses ttree pspv state)eliminate-irrelevance-clause-msg13203,140170

history-management.lisp,53405
(defrec goal-tree (children processor cl-id . fanout) nil)goal-tree37,1262
(deflabel proof-treeproof-tree95,4572
(deflabel proof-tree-examplesproof-tree-examples181,8507
(defun start-proof-tree-fn (remove-inhibit-p state)start-proof-tree-fn452,18636
(defmacro start-proof-tree ()start-proof-tree465,19018
(defmacro start-proof-tree ()start-proof-tree494,20059
(defmacro checkpoint-forced-goals (val)checkpoint-forced-goals504,20350
(defun stop-proof-tree-fn (state)stop-proof-tree-fn526,21134
(defmacro stop-proof-tree ()stop-proof-tree532,21345
(deflabel proof-tree-detailsproof-tree-details560,22404
(defun insert-into-goal-tree-rec (cl-id processor n goal-tree)insert-into-goal-tree-rec605,24607
(defun insert-into-goal-tree-lst (cl-id processor n goal-tree-lst)insert-into-goal-tree-lst613,24929
(defun insert-into-goal-tree (cl-id processor n goal-tree)insert-into-goal-tree637,25726
(defun set-difference-equal-changedp (l1 l2)set-difference-equal-changedp660,26743
(defun prune-goal-tree (forcing-round dead-clause-ids goal-tree)prune-goal-tree678,27394
(defun prune-goal-tree-lst (forcing-round dead-clause-ids goal-tree-lst)prune-goal-tree-lst765,31055
(defun prune-proof-tree (forcing-round dead-clause-ids proof-tree)prune-proof-tree782,31722
(defun print-string-repeat (increment level col channel state)print-string-repeat796,32340
(defconst *format-proc-alist**format-proc-alist*808,32743
(defun format-forced-subgoals (clause-ids col max-col channel state)format-forced-subgoals821,33141
(defun format-processor (col goal-tree channel state)format-processor850,34261
(defun format-goal-tree-lstformat-goal-tree-lst903,36276
(defun format-goal-tree (goal-tree level increment checkpointsformat-goal-tree935,37528
(defun format-proof-tree (proof-tree-rev increment checkpointsformat-proof-tree985,39680
(defun print-proof-tree1 (ctx channel state)print-proof-tree11009,40661
(defconst *proof-failure-string**proof-failure-string*1022,41221
(defun print-proof-tree-ctx (ctx channel state)print-proof-tree-ctx1025,41287
(defconst *proof-tree-start-delimiter* "#<\\<0")*proof-tree-start-delimiter*1050,42144
(defconst *proof-tree-end-delimiter* "#>\\>")*proof-tree-end-delimiter*1052,42194
(defun print-proof-tree-finish (state)print-proof-tree-finish1054,42241
(defun print-proof-tree (state)print-proof-tree1064,42669
(defun decorate-forced-goals-1 (goal-tree clause-id-list forced-clause-id)decorate-forced-goals-11089,43517
(defun decorate-forced-goals-1-lstdecorate-forced-goals-1-lst1106,44227
(defun decorate-forced-goals (forcing-round goal-tree clause-id-list-list n)decorate-forced-goals1131,45124
(defun decorate-forced-goals-in-proof-treedecorate-forced-goals-in-proof-tree1149,45764
(defun assumnote-list-to-clause-id-list (assumnote-list)assumnote-list-to-clause-id-list1167,46501
(defun assumnote-list-list-to-clause-id-list-list (assumnote-list-list)assumnote-list-list-to-clause-id-list-list1173,46723
(defun extend-proof-tree-for-forcing-roundextend-proof-tree-for-forcing-round1179,46994
(defun initialize-proof-tree1 (parent-clause-id x pool-lst forcing-round ctxinitialize-proof-tree11213,48216
(defun initialize-proof-tree (parent-clause-id x ctx state)initialize-proof-tree1251,49760
(defconst *star-1-clause-id**star-1-clause-id*1276,50788
(defun revert-goal-tree-rec (cl-id revertp goal-tree)revert-goal-tree-rec1285,50945
(defun revert-goal-tree-lst (or-p cl-id revertp goal-tree-lst)revert-goal-tree-lst1310,52080
(defun revert-goal-tree (cl-id revertp goal-tree)revert-goal-tree1337,53296
(defrec pool-element (tag clause-set . hint-settings) t)pool-element1358,54210
(defun pool-lst1 (pool n ans)pool-lst11360,54268
(defun pool-lst (pool)pool-lst1367,54522
(defun increment-proof-treeincrement-proof-tree1388,55371
(defun goal-tree-with-cl-id (cl-id goal-tree-lst)goal-tree-with-cl-id1477,59673
(defun goal-tree-choose-disjunct-rec (cl-id disjunct-cl-id goal-tree)goal-tree-choose-disjunct-rec1486,59949
(defun goal-tree-choose-disjunct-lst (cl-id disjunct-cl-id goal-tree-lst)goal-tree-choose-disjunct-lst1515,61177
(defun goal-tree-choose-disjunct (cl-id disjunct-cl-id goal-tree)goal-tree-choose-disjunct1530,61982
(defun install-disjunct-into-proof-tree (cl-id disjunct-cl-id state)install-disjunct-into-proof-tree1541,62419
(defun logical-namep (name wrld)logical-namep1599,65288
(defun logical-name-type-string (typ)logical-name-type-string1618,65979
(defun signature-fns (signatures)signature-fns1717,71018
(defun make-event-tuple (n d form ev-type namex symbol-class)make-event-tuple1732,71630
(defun access-event-tuple-number (x)access-event-tuple-number1784,74129
(defun access-event-tuple-depth (x)access-event-tuple-depth1792,74377
(defun access-event-tuple-type (x)access-event-tuple-type1795,74452
(defun access-event-tuple-namex (x)access-event-tuple-namex1804,74688
(defun access-event-tuple-form (x)access-event-tuple-form1827,75490
(defun access-event-tuple-symbol-class (x)access-event-tuple-symbol-class1832,75580
(defrec command-tuplecommand-tuple1856,76809
(defun make-command-tuple (n defun-mode form cbd last-make-event-expansion)make-command-tuple1873,77469
(defun access-command-tuple-number (x)access-command-tuple-number1891,78183
(defun access-command-tuple-defun-mode (x)access-command-tuple-defun-mode1894,78259
(defun access-command-tuple-form (x)access-command-tuple-form1900,78425
(defun safe-access-command-tuple-form (x)safe-access-command-tuple-form1910,78667
(defun access-command-tuple-last-make-event-expansion (x)access-command-tuple-last-make-event-expansion1923,79017
(defun access-command-tuple-cbd (x)access-command-tuple-cbd1926,79131
(defun max-absolute-event-number (wrld)max-absolute-event-number1931,79239
(defun next-absolute-event-number (wrld)next-absolute-event-number1941,79638
(defun max-absolute-command-number (wrld)max-absolute-command-number1944,79721
(defun next-absolute-command-number (wrld)next-absolute-command-number1952,80000
(defun scan-to-event (wrld)scan-to-event1957,80117
(defun scan-to-command (wrld)scan-to-command1968,80405
(defun scan-to-landmark-number (flg n wrld)scan-to-landmark-number1978,80667
(defun add-to-zap-table (val zt)add-to-zap-table2115,88260
(defun fetch-from-zap-table (n zt)fetch-from-zap-table2123,88502
(defconst *event-index-interval* 10)*event-index-interval*2142,89183
(defconst *command-index-interval* 10)*command-index-interval*2143,89220
(defun update-world-index (flg wrld)update-world-index2145,89260
(defun lookup-world-index1 (n interval index wrld)lookup-world-index12219,92801
(defun lookup-world-index (flg n wrld)lookup-world-index2241,93707
(defun store-absolute-event-number (namex n wrld boot-strap-flg)store-absolute-event-number2270,94959
(defun the-namex-symbol-class1 (lst wrld symbol-class1)the-namex-symbol-class12303,96187
(defun the-namex-symbol-class (namex wrld)the-namex-symbol-class2325,97459
(defun add-event-landmark (form ev-type namex wrld boot-strap-flg)add-event-landmark2333,97710
(defun scan-to-defpkg (name wrld)scan-to-defpkg2363,99108
(defun scan-to-include-book (full-book-name wrld)scan-to-include-book2378,99745
(defun assoc-equal-cadr (x alist)assoc-equal-cadr2392,100348
(defun multiple-assoc-terminal-substringp1 (x i alist)multiple-assoc-terminal-substringp12397,100508
(defun multiple-assoc-terminal-substringp (x alist)multiple-assoc-terminal-substringp2403,100817
(defun possibly-add-lisp-extension (str)possibly-add-lisp-extension2412,101207
(defun decode-logical-name (name wrld)decode-logical-name2428,101683
(defun er-decode-logical-name (name wrld ctx state)er-decode-logical-name2471,103230
(defun renew-lemmas (fn lemmas)renew-lemmas2503,104500
(defun renew-name/erase (name old-getprops wrld)renew-name/erase2514,104942
(defun renew-name/overwrite (name old-getprops wrld)renew-name/overwrite2540,105980
(defun renew-name (name renewal-mode wrld)renew-name2693,112019
(defun renew-names (names renewal-mode wrld)renew-names2736,114109
(defun collect-redefined (wrld ans)collect-redefined2742,114327
(defun scrunch-eq (lst)scrunch-eq2762,115120
(defun print-redefinition-warning (wrld ctx state)print-redefinition-warning2767,115289
(defun initialize-summary-accumulators (state)initialize-summary-accumulators2805,116935
(defun print-warnings-summary (state)print-warnings-summary2847,118723
(defun print-time-summary (state)print-time-summary2871,119542
(defun prover-steps (state)prover-steps2934,122101
(defun print-steps-summary (steps state)print-steps-summary2954,123001
(defun print-rules-summary (state)print-rules-summary2973,123768
(defun merge-cdr-> (l1 l2)merge-cdr->3003,124991
(defun merge-sort-cdr-> (l)merge-sort-cdr->3011,125237
(defconst *gag-prefix* "([ ")*gag-prefix*3016,125402
(defconst *gag-suffix* (msg "])~|"))*gag-suffix*3017,125432
(defun gag-start-msg (cl-id pool-name)gag-start-msg3019,125470
(defun print-gag-info (info state)print-gag-info3027,125711
(defun set-checkpoint-summary-limit-fn (val state)set-checkpoint-summary-limit-fn3038,126150
(defmacro set-checkpoint-summary-limit (val)set-checkpoint-summary-limit3057,126801
(defun print-gag-stack-rev (lst limit orig-limit msg chan state)print-gag-stack-rev3121,129188
(defun maybe-print-nil-goal-generated (gag-state chan state)maybe-print-nil-goal-generated3146,130370
(defun print-gag-state1 (gag-state state)print-gag-state13154,130692
(defun erase-gag-state (state)erase-gag-state3242,134467
(defun print-gag-state (state)print-gag-state3252,134920
(defun clause-id-is-top-level (cl-id)clause-id-is-top-level3260,135151
(defun clause-id-is-induction-round (cl-id)clause-id-is-induction-round3265,135309
(defun clause-id-is-forcing-round (cl-id)clause-id-is-forcing-round3270,135466
(defun print-acl2p-checkpoints1 (checkpoints top-level-banner-printedprint-acl2p-checkpoints13278,135664
(deflock *acl2p-checkpoint-saving-lock*)*acl2p-checkpoint-saving-lock*3322,137783
(defun erase-acl2p-checkpoints-for-summary (state)erase-acl2p-checkpoints-for-summary3325,137836
(defun print-acl2p-checkpoints (state)print-acl2p-checkpoints3330,137997
(defun character-alistp (x)character-alistp3361,139478
(defun tilde-@p (arg)tilde-@p3376,139940
(defun print-failure (erp ctx state)print-failure3383,140109
(defstub initialize-event-user (ctx qbody state) state)initialize-event-user3400,140846
(defstub finalize-event-user (ctx qbody state) state)finalize-event-user3402,140903
(defdoc initialize-event-userinitialize-event-user3404,140958
(defdoc finalize-event-userfinalize-event-user3472,143507
(defun lmi-seed (lmi)lmi-seed3598,148259
(defun lmi-techs (lmi)lmi-techs3616,148954
(defun lmi-seed-lst (lmi-lst)lmi-seed-lst3626,149258
(defun lmi-techs-lst (lmi-lst)lmi-techs-lst3631,149428
(defun filter-atoms (flg lst)filter-atoms3636,149597
(defun print-runes-summary (ttree channel state)print-runes-summary3646,149882
(defun use-names-in-ttree (ttree)use-names-in-ttree3659,150260
(defun by-names-in-ttree (ttree)by-names-in-ttree3666,150527
(defrec clause-processor-hintclause-processor-hint3673,150779
(defun clause-processor-fns (cl-proc-hints)clause-processor-fns3677,150850
(defun cl-proc-names-in-ttree (ttree)cl-proc-names-in-ttree3684,151149
(defun print-hint-events-summary (ttree channel state)print-hint-events-summary3690,151387
(defun print-splitter-rules-summary (cl-id clauses ttree channel state)print-splitter-rules-summary3713,152465
(defun print-rules-and-hint-events-summary (state)print-rules-and-hint-events-summary3772,155071
(defun last-prover-steps (state)last-prover-steps3800,156416
(defun print-summary (erp noop-flg ctx state)print-summary3854,158784
(defun with-prover-step-limit-fn (limit form no-change-flg)with-prover-step-limit-fn4014,165599
(defmacro with-prover-step-limit (limit formwith-prover-step-limit4109,169384
(defmacro with-prover-step-limit (limit formwith-prover-step-limit4268,176854
(defmacro with-prover-step-limit! (limit form &optional no-change-flg)with-prover-step-limit!4275,177129
(defrec proved-functional-instances-alist-entryproved-functional-instances-alist-entry4291,177781
(defun supply-name-for-proved-functional-instances-alist-entry (name lst)supply-name-for-proved-functional-instances-alist-entry4347,180684
(defun proved-functional-instances-from-tagged-objects (name lst)proved-functional-instances-from-tagged-objects4354,180994
(defun add-command-landmark (defun-mode form cbd last-make-event-expansionadd-command-landmark4593,189413
(defun find-longest-common-retraction1 (wrld1 wrld2)find-longest-common-retraction14629,191173
(defun find-longest-common-retraction1-event (wrld1 wrld2)find-longest-common-retraction1-event4635,191395
(defun find-longest-common-retraction (event-p wrld1 wrld2)find-longest-common-retraction4641,191619
(defun install-global-enabled-structure (wrld state)install-global-enabled-structure4662,192468
(defvar *defattach-fns*)*defattach-fns*4698,194179
(defun set-w (flg wrld state)set-w4700,194205
(defun set-w! (wrld state)set-w!4777,197641
(defmacro save-event-state-globals (form)save-event-state-globals4887,203123
(defun attachment-alist (fn wrld)attachment-alist4905,203705
(defun attachment-pair (fn wrld)attachment-pair4914,204089
(defconst *protected-system-state-globals**protected-system-state-globals*4920,204313
(defun state-global-bindings (names)state-global-bindings4974,207737
(defmacro protect-system-state-globals (form)protect-system-state-globals4980,207936
(defun formal-value-triple (erp val)formal-value-triple4991,208285
(defun formal-value-triple@par (erp val)formal-value-triple@par5002,208581
(defun@par translate-simple-or-error-triple (uform ctx wrld state)translate-simple-or-error-triple5009,208738
(defun xtrans-eval (uterm alist trans-flg ev-flg ctx state aok)xtrans-eval5098,213169
(defun xtrans-eval-with-ev-w (uterm alist trans-flg ev-flg ctx state aok)xtrans-eval-with-ev-w5190,217006
(defun xtrans-eval@par (uterm alist trans-flg ev-flg ctx state aok)xtrans-eval@par5266,219906
(defmacro xtrans-eval-state-fn-attachment (form ctx)xtrans-eval-state-fn-attachment5269,220045
(defmacro with-ctx-summarized (ctx body)with-ctx-summarized5303,221477
(defmacro revert-world-on-error (form)revert-world-on-error5390,225782
(defun@par chk-theory-expr-value1 (lst wrld expr macro-aliases ctx state)chk-theory-expr-value15408,226563
(defun@par chk-theory-expr-value (lst wrld expr ctx state)chk-theory-expr-value5436,227918
(defun theory-fn-translated-callp (x)theory-fn-translated-callp5444,228267
(defun eval-theory-expr (expr ctx wrld state)eval-theory-expr5463,228867
(defun eval-theory-expr@par (expr ctx wrld state)eval-theory-expr@par5498,230066
(defun append-strip-cdrs (x y)append-strip-cdrs5540,231611
(defun no-rune-based-on (runes symbols)no-rune-based-on5547,231768
(defun revappend-delete-runes-based-on-symbols1 (runes symbols ans)revappend-delete-runes-based-on-symbols15553,231956
(defun revappend-delete-runes-based-on-symbols (runes symbols ans)revappend-delete-runes-based-on-symbols5565,232510
(defun current-theory1 (lst ans redefined)current-theory15586,233449
(defun first-n-ac-rev (i l ac)first-n-ac-rev5624,235256
(defun longest-common-tail-length-rec (old new acc)longest-common-tail-length-rec5640,235813
(defun longest-common-tail-length (old new)longest-common-tail-length5654,236380
(defun extend-current-theory (old-th new-th old-aug-th wrld)extend-current-theory5663,236728
(defun update-current-theory (theory0 wrld)update-current-theory5698,238212
(defun put-cltl-command (cltl-cmd wrld wrld0)put-cltl-command5722,239429
(defun strip-non-nil-base-symbols (runes acc)strip-non-nil-base-symbols5739,240198
(defun install-proof-supporters (namex ttree wrld)install-proof-supporters5747,240462
(defun install-event (val form ev-type namex ttree cltl-cmdinstall-event5785,242297
(deflabel redundant-eventsredundant-events6001,254263
(defun stop-redundant-event-fn (ctx state extra-msg)stop-redundant-event-fn6301,269461
(defmacro stop-redundant-event (ctx state &optional extra-msg)stop-redundant-event6332,270602
(defrec command-number-baseline-infocommand-number-baseline-info6368,272247
(defun absolute-to-relative-command-number (n wrld)absolute-to-relative-command-number6372,272327
(defun relative-to-absolute-command-number (n wrld)relative-to-absolute-command-number6377,272514
(defun normalize-absolute-command-number (n wrld)normalize-absolute-command-number6382,272701
(defun tree-occur (x y)tree-occur6432,274631
(defun cd-form-matchp (pat form)cd-form-matchp6441,274820
(defun cd-some-event-matchp (pat wrld)cd-some-event-matchp6454,275196
(defun cd-search (pat earliestp start-wrld end-wrld)cd-search6473,275976
(defun superior-command-world (wrld1 wrld ctx state)superior-command-world6514,277780
(defun er-decode-cd (cd wrld ctx state)er-decode-cd6545,279268
(defrec ldd-statusldd-status6732,288481
(defun make-ldd-flags (class markp status fullp)make-ldd-flags6736,288619
(defun make-ldd (class markp status n fullp form)make-ldd6749,289296
(defun access-ldd-class  (ldd) (caaar ldd))access-ldd-class6766,289981
(defun access-ldd-markp  (ldd) (cdaar ldd))access-ldd-markp6767,290025
(defun access-ldd-status (ldd) (cadar ldd))access-ldd-status6768,290069
(defun access-ldd-fullp  (ldd) (cddar ldd))access-ldd-fullp6769,290113
(defun access-ldd-n      (ldd) (cadr ldd))access-ldd-n6770,290157
(defun access-ldd-form   (ldd) (cddr ldd))access-ldd-form6771,290200
(defun big-d-little-d-name1 (lst ens ans)big-d-little-d-name16773,290244
(defun big-d-little-d-name (name ens wrld)big-d-little-d-name6787,290868
(defun big-d-little-d-clique1 (names ens wrld ans)big-d-little-d-clique16801,291510
(defun big-d-little-d-clique (names ens wrld)big-d-little-d-clique6814,292060
(defun big-d-little-d-event (ev-tuple ens wrld)big-d-little-d-event6825,292519
(defun big-d-little-d-command-block (wrld1 ens wrld s)big-d-little-d-command-block6851,293735
(defun big-m-little-m-name (name wrld)big-m-little-m-name6894,295745
(defun big-m-little-m-clique1 (names wrld ans)big-m-little-m-clique16907,296180
(defun big-m-little-m-clique (names wrld)big-m-little-m-clique6920,296672
(defun big-m-little-m-event (ev-tuple wrld)big-m-little-m-event6930,297040
(defun big-m-little-m-command-block (wrld1 wrld s)big-m-little-m-command-block6944,297574
(defun symbol-class-char (symbol-class)symbol-class-char6972,298648
(defun defun-mode-string (defun-mode)defun-mode-string6983,298964
(defun big-c-little-c-event (ev-tuple wrld)big-c-little-c-event6991,299218
(defun big-c-little-c-command-block (wrld1 wrld s)big-c-little-c-command-block7018,300487
(defun print-ldd-full-or-sketch/mutual-recursion (lst)print-ldd-full-or-sketch/mutual-recursion7056,302287
(defun print-ldd-full-or-sketch/encapsulate (lst)print-ldd-full-or-sketch/encapsulate7065,302595
(defun normalize-char (c hyphen-is-spacep)normalize-char7078,303121
(defun normalize-string1 (str hyphen-is-spacep j ans)normalize-string17084,303277
(defun normalize-string (str hyphen-is-spacep)normalize-string7096,303811
(defun string-matchp (pat-lst str j jmax normp skippingp)string-matchp7106,304216
(defun string-search1 (pat-lst str j j-max normp)string-search17132,305204
(defun string-search (pat str normp)string-search7139,305431
(defun doc-stringp (str)doc-stringp7156,306022
(defconst *zapped-doc-string**zapped-doc-string*7173,306522
(defun zap-doc-string-from-event-form/all-but-last (lst)zap-doc-string-from-event-form/all-but-last7176,306591
(defun zap-doc-string-from-event-form/second-arg (form)zap-doc-string-from-event-form/second-arg7185,306950
(defun zap-doc-string-from-event-form/third-arg (form)zap-doc-string-from-event-form/third-arg7195,307218
(defun zap-doc-string-from-event-form/mutual-recursion (lst)zap-doc-string-from-event-form/mutual-recursion7206,307542
(defun zap-doc-string-from-event-form/doc-keyword (lst)zap-doc-string-from-event-form/doc-keyword7211,307783
(defun zap-doc-string-from-event-form (form)zap-doc-string-from-event-form7232,308749
(defun print-ldd-full-or-sketch (fullp form)print-ldd-full-or-sketch7251,309530
(defmacro with-base-10 (form)with-base-107300,311320
(defun print-ldd-formula-column (state)print-ldd-formula-column7330,312644
(defun print-ldd (ldd channel state)print-ldd7335,312788
(defun print-ldds (ldds channel state)print-ldds7392,315020
(defun make-command-ldd (markp fullp cmd-wrld ens wrld)make-command-ldd7423,316575
(defun make-event-ldd (markp indent fullp ev-tuple ens wrld)make-event-ldd7442,317408
(defun make-ldds-command-sequence (cmd-wrld1 cmd2 ens wrld markp ans)make-ldds-command-sequence7457,317962
(defun make-ldds-command-block1 (wrld1 cmd-ldd indent fullp super-stk ens wrldmake-ldds-command-block17481,319089
(defun make-ldds-command-block (cmd-wrld ens wrld fullp ans)make-ldds-command-block7552,321505
(defun pcb-pcb!-fn (cd fullp state)pcb-pcb!-fn7570,322290
(defun pcb!-fn (cd state)pcb!-fn7583,322753
(defun pcb-fn (cd state)pcb-fn7586,322808
(defmacro pcb! (cd)pcb!7589,322864
(defun pc-fn (cd state)pc-fn7609,323495
(defmacro pc (cd)pc7621,323904
(defun pcs-fn (cd1 cd2 markp state)pcs-fn7753,330037
(defmacro pcs (cd1 cd2)pcs7808,332611
(defun get-command-sequence-fn1 (cmd-wrld1 cmd2 ans)get-command-sequence-fn17833,333554
(defun get-command-sequence-fn (cd1 cd2 state)get-command-sequence-fn7846,333976
(defmacro get-command-sequence (cd1 cd2)get-command-sequence7871,335052
(defmacro gcs (cd1 cd2)gcs7895,335925
(defmacro pbt (cd1)pbt7898,335987
(defmacro pcb (cd)pcb7922,336880
(defun print-indented-list-msg (objects indent final-string)print-indented-list-msg7953,338358
(defun print-indented-list (objects indent last-col channel evisc-tuple state)print-indented-list7972,339007
(defun print-book-path (book-path indent channel state)print-book-path7979,339293
(defun pe-fn1 (wrld channel ev-wrld cmd-wrld state)pe-fn17994,339803
(defun pe-fn2 (logical-name wrld channel ev-wrld state)pe-fn28024,340850
(defun pe-fn (logical-name state)pe-fn8034,341388
(defmacro pe (logical-name)pe8092,343959
(defmacro pe! (logical-name)pe!8140,345794
(defun command-block-names1 (wrld ans symbol-classes)command-block-names18155,346197
(defun command-block-names (wrld symbol-classes)command-block-names8190,347892
(defun symbol-name-lst (lst)symbol-name-lst8199,348265
(defun acl2-query-simulate-interaction (msg alist controlledp ans state)acl2-query-simulate-interaction8204,348410
(defun acl2-query1 (id qt alist state)acl2-query18222,349122
(defun acl2-query (id qt alist state)acl2-query8275,351238
(defun collect-names-in-defun-modes (names defun-modes wrld)collect-names-in-defun-modes8325,353576
(defun ubt-ubu-query (kwd wrld1 wrld0 seen kept-commands wrld state banger)ubt-ubu-query8336,354019
(defmacro ubt (cd)ubt8459,360909
(defmacro ubt! (cd)ubt!8502,362870
(defmacro ubu (cd)ubu8520,363410
(defmacro ubu! (cd)ubu!8551,364624
(defmacro u nilu8570,365199
(defun chk-virgin (name new-type wrld)chk-virgin8592,365880
(deflabel namename8604,366140
(defun chk-boot-strap-redefineable-namep (name ctx wrld state)chk-boot-strap-redefineable-namep8651,368367
(defun maybe-coerce-overwrite-to-erase (old-type new-type mode)maybe-coerce-overwrite-to-erase8667,369078
(defun redefinition-renewal-mode (name old-type new-type reclassifyingp ctxredefinition-renewal-mode8673,369256
(defun redefined-names1 (wrld ans)redefined-names19010,385981
(defun redefined-names (state)redefined-names9020,386359
(defun chk-redefineable-namep (name new-type reclassifyingp ctx wrld state)chk-redefineable-namep9071,388236
(defun chk-just-new-name (name new-type reclassifyingp ctx w state)chk-just-new-name9130,390790
(defun no-new-namesp (lst wrld)no-new-namesp9182,393148
(defun chk-just-new-names (names new-type reclassifyingp ctx w state)chk-just-new-names9191,393368
(defconst *return-character* (code-char 13))*return-character*9217,394586
(defun read-symbol-from-string1 (str i len ans)read-symbol-from-string19219,394632
(defun read-symbol-from-string2 (str i len ans)read-symbol-from-string29234,395196
(defun read-symbol-from-string (str i pkg-witness)read-symbol-from-string9243,395527
(defun scan-past-newline (str i maximum)scan-past-newline9294,398087
(defun scan-past-newlines (str i maximum)scan-past-newlines9301,398303
(defun scan-past-tilde-slash (str i maximum)scan-past-tilde-slash9308,398516
(defun scan-to-doc-string-part1 (parti str i maximum)scan-to-doc-string-part19320,399081
(defun scan-to-doc-string-part (i str)scan-to-doc-string-part9331,399384
(defun get-one-liner-as-string1 (str i j acc)get-one-liner-as-string19350,400146
(defun get-one-liner-as-string (str)get-one-liner-as-string9355,400320
(defun read-doc-string-citations1 (name str i)read-doc-string-citations19363,400603
(defun read-doc-string-citations (name str)read-doc-string-citations9377,401111
(defun doc-topicp (name wrld)doc-topicp9393,401880
(defun ignore-doc-string-error (wrld)ignore-doc-string-error9396,401972
(defmacro er-doc (ctx str &rest str-args)er-doc9400,402113
(defun chk-doc-string-citations (str citations wrld)chk-doc-string-citations9414,402749
(defun chk-well-formed-doc-string (name doc ctx state)chk-well-formed-doc-string9446,404314
(defun translate-doc (name doc ctx state)translate-doc9540,408901
(defun translate-doc-lst (names docs ctx state)translate-doc-lst9562,409820
(defun get-cites (citations)get-cites9569,410098
(defun alpha-< (x y)alpha-<9580,410435
(defun merge-alpha-< (l1 l2)merge-alpha-<9600,411178
(defun merge-sort-alpha-< (l)merge-sort-alpha-<9607,411403
(defun update-alpha-<-alist (key val alist)update-alpha-<-alist9612,411578
(defun put-cited-bys (name citations alist)put-cited-bys9624,412028
(defun update-doc-database (name doc pair wrld)update-doc-database9649,412969
(defun update-doc-database-lst (names docs pairs wrld)update-doc-database-lst9674,414047
(defun putprop-unless (sym key val exception wrld)putprop-unless9682,414316
(defun redefined-warning (redef ctx state)redefined-warning9690,414578
(defun get-event (name wrld)get-event9703,415036
(defun redundant-labelp (name event-form wrld)redundant-labelp9716,415392
(defun deflabel-fn (name state doc event-form)deflabel-fn9726,415756
(defun defdoc-fn (name state doc event-form)defdoc-fn9775,417566
(defmacro defdoc (&whole event-form name doc) ;See notedefdoc9825,419365
(defun access-doc-string-database (name state)access-doc-string-database9897,422715
(defun get-doc-string (name state)get-doc-string9930,423864
(defun get-doc-string-de-indent1 (str i)get-doc-string-de-indent19937,424046
(defun get-doc-string-de-indent (str)get-doc-string-de-indent9941,424187
(defun use-doc-string-de-indent (d str i maximum)use-doc-string-de-indent9953,424703
(defun doc-prefix (state)doc-prefix9964,425023
(defun princ-prefix (prefix channel state)princ-prefix9969,425144
(defun length-prefix (prefix)length-prefix9975,425386
(defun save-more-doc-state (str i maximum de-indent prefix state)save-more-doc-state9979,425511
(defun doc-char-subst-table-p (x)doc-char-subst-table-p9988,425900
(defun set-doc-char-subst-table (x state)set-doc-char-subst-table10001,426195
(defun doc-char-subst-table (state)doc-char-subst-table10011,426616
(defun doc-fmt-alist (state)doc-fmt-alist10017,426741
(defconst *terminal-markup-table**terminal-markup-table*10020,426810
(defun doc-markup-table (state)doc-markup-table10149,433554
(defun doc-scan-past-tilde-key (name orig-position posn str maximum acc state)doc-scan-past-tilde-key10154,433723
(defun doc-scan-past-tilde-argdoc-scan-past-tilde-arg10182,434989
(defun doc-scan-past-tildedoc-scan-past-tilde10254,437825
(defun assoc-char-alist-stringp (char-alist str len)assoc-char-alist-stringp10292,439582
(defun apply-char-subst-table1 (char-lst acc char-subst-table)apply-char-subst-table110302,439895
(defun apply-char-subst-table (s char-subst-table spack)apply-char-subst-table10323,440788
(defun read-pointer-and-text1 (lst pacc sacc)read-pointer-and-text110350,441843
(defun read-pointer-and-text2 (lst acc)read-pointer-and-text210374,442929
(defun read-pointer-and-text-raw (str)read-pointer-and-text-raw10383,443261
(defun posn-char-stringp (chr str i)posn-char-stringp10396,443672
(defun replace-colons (p)replace-colons10406,443896
(defun read-pointer-and-text (str bar-sep-p)read-pointer-and-text10419,444315
(defun lookup-fmt-alist (str flag fmt-alist char-subst-table bar-sep-p)lookup-fmt-alist10427,444542
(defun bar-sep-p (state)bar-sep-p10517,448684
(defun char-to-string-alistp (lst)char-to-string-alistp10521,448793
(defun missing-fmt-alist-chars1 (str char-to-tilde-s-string-alist fmt-alist)missing-fmt-alist-chars110532,449123
(defun missing-fmt-alist-chars (str fmt-alist)missing-fmt-alist-chars10553,450008
(defun complete-fmt-alist (topic-name fmt-alist undocumented-filecomplete-fmt-alist10579,451227
(defmacro mv-to-state (n form)mv-to-state10606,452457
(defun print-par-entry (entry fmt-alist char-subst-table channel state)print-par-entry10620,452885
(defun print-doc-string-part1 (str i maximum de-indent prefixprint-doc-string-part110628,453139
(defun print-doc-string-part-mvprint-doc-string-part-mv10943,469591
(defun print-doc-string-partprint-doc-string-part11040,474219
(defun get-doc-section (section alist)get-doc-section11049,474560
(defmacro pstate-global-let* (bindings body)pstate-global-let*11057,474855
(defun print-doc (name n prefixprint-doc11071,475283
(defun print-doc-lst (lst prefixprint-doc-lst11164,479291
(defun degree-of-match2 (ch1 ch2 str i maximum)degree-of-match211181,479970
(defun degree-of-match1 (pat-lst str maximum)degree-of-match111189,480269
(defun degree-of-match (pat-lst str)degree-of-match11195,480515
(defun find-likely-near-misses (pat-lst alist)find-likely-near-misses11209,481052
(defun print-doc-dwim (name ctx state)print-doc-dwim11227,481867
(defun end-doc (channel state)end-doc11244,482486
(defun doc-fn (name state)doc-fn11258,482950
(defun more-fn (ln state)more-fn11314,485481
(defun doc!-fn (name state)doc!-fn11338,486534
(defmacro more nilmore11364,487731
(defmacro more! nilmore!11412,489806
(defun print-doc-outlineprint-doc-outline11437,490657
(defun print-doc-outline-lst (name-lst prefixprint-doc-outline-lst11467,491782
(deflabel finding-documentationfinding-documentation11481,492511
(deflabel markupmarkup11506,493682
(deflabel doc-stringdoc-string11789,505147
(deflabel print-doc-start-columnprint-doc-start-column12021,517849
(defmacro doc (name)doc12043,518737
(defmacro doc! (name)doc!12108,521731
(defun more-doc-fn (name state)more-doc-fn12126,522149
(defmacro more-doc (name)more-doc12145,522924
(defun get-doc-section-symbols (alist ans)get-doc-section-symbols12171,523902
(defun get-docs-apropos1 (pat-lst alist ans)get-docs-apropos112176,524095
(defun get-docs-apropos (pat alist)get-docs-apropos12182,524370
(defun docs-fn (x state)docs-fn12185,524475
(defmacro docs (x)docs12240,526641
(defun print-top-doc-topics (doc-alist channel state)print-top-doc-topics12289,528657
(defun help-fn (state)help-fn12301,529114
(deflabel qq12359,531677
(defmacro help nilhelp12381,532476
(deflabel logical-namelogical-name12396,532719
(deflabel commandcommand12471,536262
(deflabel command-descriptorcommand-descriptor12497,537299
(defun trans-fn (form state)trans-fn12585,541680
(defun trans!-fn (form state)trans!-fn12612,542884
(defmacro trans (form)trans12633,543731
(defmacro trans! (form)trans!12679,545141
(defun trans1-fn (form state)trans1-fn12696,545610
(defmacro trans1 (form)trans112706,545997
(defun tilde-*-props-fn-phrase1 (alist)tilde-*-props-fn-phrase112726,546515
(defun tilde-*-props-fn-phrase (alist)tilde-*-props-fn-phrase12733,546751
(defun props-fn (sym state)props-fn12737,546867
(defmacro props (sym)props12758,547641
(deflabel enter-boot-strap-modeenter-boot-strap-mode12773,547938
(deflabel exit-boot-strap-modeexit-boot-strap-mode12804,549387
(defun walkabout-nth (i x)walkabout-nth12828,550351
(defun walkabout-ip (i x)walkabout-ip12851,551174
(defun walkabout-huh (state)walkabout-huh12862,551494
(defun walkabout1 (i x state intern-flg evisc-tuple alt-evisc-tuple)walkabout112867,551647
(defun walkabout (x state)walkabout12966,555822
(defun walkabout=-fn (var state)walkabout=-fn13081,558865
(defmacro walkabout= (var)walkabout=13086,559009
(defun lookup-bddnote (cl-id bddnotes)lookup-bddnote13091,559140
(defun update-bddnote-with-term (cl-id term bddnotes)update-bddnote-with-term13098,559337
(defmacro show-bdd (&optional strshow-bdd13111,559815
(defun show-bdd-goal (query-response bddnote chan state)show-bdd-goal13200,563669
(defun merge-car-term-order (l1 l2)merge-car-term-order13251,565826
(defun merge-sort-car-term-order (l)merge-sort-car-term-order13258,566087
(defun falsifying-pair-p (term val asst)falsifying-pair-p13263,566297
(defun bogus-falsifying-assignment-var (asst)bogus-falsifying-assignment-var13272,566594
(defun show-falsifying-assignment (query-response bddnote chan state)show-falsifying-assignment13283,566846
(defun show-bdd-term (query-response bddnote chan state)show-bdd-term13359,570480
(defun tilde-*-substitution-phrase1 (alist is-replaced-by-str evisc-tuple wrld)tilde-*-substitution-phrase113428,573417
(defun tilde-*-substitution-phrase (alist is-replaced-by-str evisc-tuple wrld)tilde-*-substitution-phrase13439,573949
(defun show-bdd-backtrace (call-stack cst-array chan state)show-bdd-backtrace13445,574202
(defun show-bdd-fn (str goal-query-responseshow-bdd-fn13474,575266
(defun get-docs (lst)get-docs13536,578226
(defun get-guards2 (edcls targets wrld acc)get-guards213549,578664
(defun get-guards1 (edcls targets wrld)get-guards113633,582343
(defun get-guards (lst split-types-lst split-types-p wrld)get-guards13636,582424
(defun get-guardsp (lst wrld)get-guardsp13681,584419
(defconst *no-measure**no-measure*13699,585287
(defun get-measures1 (m edcls ctx state)get-measures113702,585320
(defun get-measures2 (lst ctx state)get-measures213733,586851
(defun get-measures (symbol-class lst ctx state)get-measures13741,587154
(defconst *no-ruler-extenders**no-ruler-extenders*13757,587784
(defconst *basic-ruler-extenders**basic-ruler-extenders*13760,587825
(defun get-ruler-extenders1 (r edcls default ctx wrld state)get-ruler-extenders113763,587886
(defun get-ruler-extenders2 (lst default ctx wrld state)get-ruler-extenders213808,589981
(defmacro default-ruler-extenders-from-table (alist)default-ruler-extenders-from-table13817,590410
(defun default-ruler-extenders (wrld)default-ruler-extenders13823,590606
(defun get-ruler-extenders-lst (symbol-class lst ctx state)get-ruler-extenders-lst13842,591446
(defun get-hints1 (edcls)get-hints113860,592245
(defun get-hints (lst)get-hints13887,593162
(defun get-guard-hints1 (edcls)get-guard-hints113897,593474
(defun get-guard-hints (lst)get-guard-hints13925,594453
(defun get-std-hints1 (edcls)get-std-hints113936,594814
(defun get-std-hints (lst)get-std-hints13965,595776
(defun get-normalizep (edcls ans ctx state)get-normalizep13975,596104
(defun get-normalizeps (lst acc ctx state)get-normalizeps14014,597504
(defconst *unspecified-xarg-value**unspecified-xarg-value*14025,598001
(defun get-unambiguous-xargs-flg1/edcls1 (key v edcls event-msg)get-unambiguous-xargs-flg1/edcls114032,598143
(defun get-unambiguous-xargs-flg1/edcls (key v edcls event-msg ctx state)get-unambiguous-xargs-flg1/edcls14065,599861
(defun get-unambiguous-xargs-flg1 (key lst event-msg ctx state)get-unambiguous-xargs-flg114076,600249
(defun get-unambiguous-xargs-flg (key lst default ctx state)get-unambiguous-xargs-flg14094,601190
(defun get-unambiguous-xargs-flg-lst (key lst default ctx state)get-unambiguous-xargs-flg-lst14123,602722
(defun chk-xargs-keywords1 (edcls keywords ctx state)chk-xargs-keywords114144,603747
(defun chk-xargs-keywords (lst keywords ctx state)chk-xargs-keywords14161,604593
(defun get-names (lst)get-names14182,605419
(defun get-bodies (lst)get-bodies14187,605539
(defun find-nontrivial-rulers (var term)find-nontrivial-rulers14194,605687
(defun find-nontrivial-rulers-lst (var termlist flg)find-nontrivial-rulers-lst14219,606729
(defun tilde-@-free-vars-phrase (vars term wrld)tilde-@-free-vars-phrase14228,607062
(defun chk-free-vars (name formals term loc-str ctx state)chk-free-vars14255,608398
(defun chk-declared-ignores (name ignores term loc-str ctx state)chk-declared-ignores14274,609238
(defun chk-free-and-ignored-vars (name formals guard split-types-term measurechk-free-and-ignored-vars14286,609755
(defun chk-free-and-ignored-vars-lsts (names arglists guards split-types-termschk-free-and-ignored-vars-lsts14343,612735
(defun putprop-x-lst1 (symbols key value wrld)putprop-x-lst114380,614924
(defun putprop-x-lst2 (symbols key vals wrld)putprop-x-lst214390,615232
(defun putprop-x-lst2-unless (symbols key vals exception wrld)putprop-x-lst2-unless14401,615578
(defun@par translate-term-lst (terms stobjs-out logic-modep known-stobjs-lsttranslate-term-lst14417,616285
(defun find-named-lemma (sym lst top-level)find-named-lemma14513,620942
(defun find-runed-lemma (rune lst)find-runed-lemma14530,621604
(defun free-varsp-member (term vars)free-varsp-member14543,621953
(defun free-varsp-member-lst (args vars)free-varsp-member-lst14551,622203
(defun@par translate-expand-term1 (name form free-vars ctx wrld state)translate-expand-term114558,622384
(defun@par translate-expand-term (x ctx wrld state)translate-expand-term14683,628178
(defun@par translate-expand-hint1 (arg acc ctx wrld state)translate-expand-hint114711,629317
(defun@par translate-expand-hint (arg ctx wrld state)translate-expand-hint14724,629872
(defun cons-all-to-lst (new-members lst)cons-all-to-lst14778,632007
(defun@par translate-substitution (substn ctx wrld state)translate-substitution14783,632189
(defun@par translate-substitution-lst (substn-lst ctx wrld state)translate-substitution-lst14832,634502
(defun get-rewrite-and-defn-runes-from-runic-mapping-pairs (pairs)get-rewrite-and-defn-runes-from-runic-mapping-pairs14842,634854
(defun@par translate-restrict-hint (arg ctx wrld state)translate-restrict-hint14851,635196
(defconst *do-not-processes**do-not-processes*14900,637286
(defun coerce-to-process-name-lst (lst)coerce-to-process-name-lst14904,637422
(defun coerce-to-acl2-package-lst (lst)coerce-to-acl2-package-lst14911,637661
(defun@par chk-do-not-expr-value (lst expr ctx state)chk-do-not-expr-value14918,637874
(defun@par translate-do-not-hint (expr ctx state)translate-do-not-hint14946,639159
(defun@par translate-do-not-induct-hint (arg ctx wrld state)translate-do-not-induct-hint14987,640730
(defun@par translate-hands-off-hint1 (arg ctx wrld state)translate-hands-off-hint115013,642051
(defun@par translate-hands-off-hint (arg ctx wrld state)translate-hands-off-hint15053,643589
(defun truncated-class (rune mapping-pairs classes)truncated-class15075,644357
(defun tests-and-alists-lst-from-fn (fn wrld)tests-and-alists-lst-from-fn15089,645052
(defun corollary (rune wrld)corollary15110,646071
(defun formula (name normalp wrld)formula15191,649551
(defun pf-fn (name state)pf-fn15212,650458
(defmacro pf (name)pf15247,651896
(defun merge-symbol-< (l1 l2 acc)merge-symbol-<15268,652537
(defun merge-sort-symbol-< (l)merge-sort-symbol-<15275,652810
(defconst *non-instantiable-primitives**non-instantiable-primitives*15283,653073
(defun instantiablep (fn wrld)instantiablep15323,654722
(defun all-ffn-symbs (term ans)all-ffn-symbs15361,656398
(defun all-ffn-symbs-lst (lst ans)all-ffn-symbs-lst15371,656793
(defconst *unknown-constraints**unknown-constraints*15378,656961
(defun constraint-info (fn wrld)constraint-info15386,657184
(defdoc constraintconstraint15453,660158
(defun@par chk-equal-arities (fn1 n1 fn2 n2 ctx state)chk-equal-arities15904,680294
(defun extend-sorted-symbol-alist (pair alist)extend-sorted-symbol-alist15924,680904
(defun@par chk-equiv-classicalp (fn1 fn2 termp ctx wrld state)chk-equiv-classicalp15938,681271
(defun@par translate-functional-substitution (substn ctx wrld state)translate-functional-substitution15957,682076
(defun sublis-fn-rec (alist term bound-vars allow-freevars-p)sublis-fn-rec16079,687797
(defun sublis-fn-rec-lst (alist terms bound-vars allow-freevars-p)sublis-fn-rec-lst16197,694000
(defun sublis-fn (alist term bound-vars)sublis-fn16212,694566
(defun sublis-fn-simple (alist term)sublis-fn-simple16219,694780
(defun sublis-fn-lst-simple (alist termlist)sublis-fn-lst-simple16229,695103
(defun instantiable-ffn-symbs (term wrld ans ignore-fns)instantiable-ffn-symbs16240,695384
(defun instantiable-ffn-symbs-lst (lst wrld ans ignore-fns)instantiable-ffn-symbs-lst16267,696386
(defun unknown-constraint-supporters (fn wrld)unknown-constraint-supporters16278,696780
(defun collect-instantiablep1 (fns wrld ignore-fns)collect-instantiablep116298,697683
(defun all-instantiablep (fns wrld)all-instantiablep16309,698060
(defun collect-instantiablep (fns wrld ignore-fns)collect-instantiablep16315,698223
(defun immediate-instantiable-ancestors (fn wrld ignore-fns)immediate-instantiable-ancestors16324,698485
(defun instantiable-ancestors (fns wrld ans)instantiable-ancestors16369,700746
(defun hitp (term alist)hitp16388,701408
(defun hitp-lst (terms alist)hitp-lst16401,701850
(defun event-responsible-for-proved-constraint (name alistevent-responsible-for-proved-constraint16408,701999
(defun getprop-x-lst (symbols prop wrld)getprop-x-lst16453,704255
(defun filter-hitps (lst alist ans)filter-hitps16459,704488
(defun relevant-constraints1 (names alist proved-fnl-insts-alist constraintsrelevant-constraints116466,704681
(defun relevant-constraints1-axioms (names alist proved-fnl-insts-alistrelevant-constraints1-axioms16632,712842
(defun relevant-constraints (thm alist proved-fnl-insts-alist wrld)relevant-constraints16682,715351
(defun bound-vars (term ans)bound-vars16733,717604
(defun bound-vars-lst (terms ans)bound-vars-lst16744,718008
(defun@par translate-lmi/instance (formula constraints event-names new-entriestranslate-lmi/instance16752,718169
(defun@par translate-lmi/functional-instance (formula constraints event-namestranslate-lmi/functional-instance16793,720260
(defun@par translate-lmi (lmi normalizep ctx wrld state)translate-lmi16890,725249
(deflabel functional-instantiation-in-acl2rfunctional-instantiation-in-acl2r16997,729843
(deflabel lemma-instancelemma-instance17020,730897
(defun@par translate-use-hint1 (arg ctx wrld state)translate-use-hint117129,736975
(defun@par translate-use-hint (arg ctx wrld state)translate-use-hint17152,738114
(defun convert-name-tree-to-new-name1 (name-tree char-lst sym)convert-name-tree-to-new-name117264,743596
(defun convert-name-tree-to-new-name (name-tree wrld)convert-name-tree-to-new-name17291,744944
(defun@par translate-by-hint (name-tree arg ctx wrld state)translate-by-hint17313,746001
(defun@par translate-cases-hint (arg ctx wrld state)translate-cases-hint17381,749086
(defun@par translate-case-split-limitations-hint (arg ctx wrld state)translate-case-split-limitations-hint17396,749574
(defun@par translate-no-op-hint (arg ctx wrld state)translate-no-op-hint17420,750522
(defun@par translate-error-hint (arg ctx wrld state)translate-error-hint17426,750670
(defun@par translate-induct-hint (arg ctx wrld state)translate-induct-hint17435,750963
(defconst *built-in-executable-counterparts**built-in-executable-counterparts*17447,751440
(defconst *s-prop-theory**s-prop-theory*17467,752106
(defconst *definition-minimal-theory**definition-minimal-theory*17480,752604
(defdoc theories-and-primitivestheories-and-primitives17488,752906
(defun translate-in-theory-hinttranslate-in-theory-hint17596,756698
(defun translate-in-theory-hint@partranslate-in-theory-hint@par17663,759762
(defun all-function-symbolps (fns wrld)all-function-symbolps17742,763585
(defun non-function-symbols (lst wrld)non-function-symbols17748,763808
(defun collect-non-logic-mode (alist wrld)collect-non-logic-mode17755,764050
(defun@par translate-bdd-hint1 (top-arg rest ctx wrld state)translate-bdd-hint117763,764361
(defun@par translate-bdd-hint (arg ctx wrld state)translate-bdd-hint17849,768392
(defun@par translate-nonlinearp-hint (arg ctx wrld state)translate-nonlinearp-hint17867,769026
(defun@par translate-backchain-limit-rw-hint (arg ctx wrld state)translate-backchain-limit-rw-hint17879,769367
(defun@par translate-no-thanks-hint (arg ctx wrld state)translate-no-thanks-hint17889,769692
(defun@par translate-reorder-hint (arg ctx wrld state)translate-reorder-hint17895,769842
(defun arity-mismatch-msg (sym expected-arity wrld)arity-mismatch-msg17907,770207
(defun@par translate-clause-processor-hint (form ctx wrld state)translate-clause-processor-hint17938,771509
(defun@par translate-custom-keyword-hint (arg uterm2 ctx wrld state)translate-custom-keyword-hint18059,777364
(defun custom-keyword-hint (key wrld)custom-keyword-hint18115,780028
(defun remove-all-no-ops (key-val-lst)remove-all-no-ops18126,780362
(defun remove-redundant-no-ops (key-val-lst)remove-redundant-no-ops18134,780667
(defun find-first-custom-keyword-hint (user-hints wrld)find-first-custom-keyword-hint18153,781264
(defconst *custom-keyword-max-iterations**custom-keyword-max-iterations*18173,782029
(defun@par custom-keyword-hint-interpreter1custom-keyword-hint-interpreter118176,782079
(defun@par custom-keyword-hint-interpretercustom-keyword-hint-interpreter18350,789612
(defun custom-keyword-hint-in-computed-hint-form (computed-hint-tuple)custom-keyword-hint-in-computed-hint-form18381,791058
(defun@par put-cl-id-of-custom-keyword-hint-in-computed-hint-formput-cl-id-of-custom-keyword-hint-in-computed-hint-form18420,792919
(defun make-disjunctive-clause-id (cl-id i pkg-name)make-disjunctive-clause-id18448,794093
(defun make-disjunctive-goal-spec (str i pkg-name)make-disjunctive-goal-spec18456,794384
(defun minimally-well-formed-or-hintp (val)minimally-well-formed-or-hintp18461,794570
(defun split-keyword-alist (key keyword-alist)split-keyword-alist18469,794840
(defun distribute-other-hints-into-or1 (pre x post)distribute-other-hints-into-or118480,795278
(defun distribute-other-hints-into-or (keyword-alist)distribute-other-hints-into-or18485,795469
(defconst *hint-expression-basic-vars**hint-expression-basic-vars*18506,796217
(defconst *hint-expression-override-vars**hint-expression-override-vars*18509,796328
(defconst *hint-expression-backtrack-vars**hint-expression-backtrack-vars*18512,796425
(defconst *hint-expression-all-vars**hint-expression-all-vars*18517,796610
(defun@par translate-hint-expression (name-tree term hint-type ctx wrld state)translate-hint-expression18522,796816
(defun@par translate-backtrack-hint (name-tree arg ctx wrld state)translate-backtrack-hint18709,804205
(defun@par translate-rw-cache-state-hint (arg ctx wrld state)translate-rw-cache-state-hint18712,804348
(defun@par translate-or-hint (name-tree str arg ctx wrld state)translate-or-hint18723,804690
(defun@par translate-hint-settings (name-tree str key-val-lst ctx wrld state)translate-hint-settings18775,806956
(defun@par translate-x-hint-value (name-tree str x arg ctx wrld state)translate-x-hint-value18809,808293
(defun replace-goal-spec-in-name-tree1 (name-tree goal-spec)replace-goal-spec-in-name-tree118883,810918
(defun replace-goal-spec-in-name-tree (name-tree goal-spec)replace-goal-spec-in-name-tree18903,811659
(defun@par translate-hint (name-tree pair hint-type ctx wrld state)translate-hint18925,812656
(defun@par translate-hint-expressions (name-tree terms hint-type ctx wrld state)translate-hint-expressions19264,829727
(defun@par check-translated-override-hint (hint uhint ctx state)check-translated-override-hint19284,830597
(defun@par translate-hints1 (name-tree lst hint-type override-hints ctx wrld state)translate-hints119295,831045
(defun@par warn-on-duplicate-hint-goal-specs (lst seen ctx state)warn-on-duplicate-hint-goal-specs19382,836056
(defun@par translate-hints2 (name-tree lst hint-type override-hints ctx wrld state)translate-hints219403,837258
(defun override-hints (wrld)override-hints19415,837907
(defun@par translate-hints (name-tree lst ctx wrld state)translate-hints19559,845629
(defun@par translate-hints+1 (name-tree lst default-hints ctx wrld state)translate-hints+119563,845793
(defun translate-hints+ (name-tree lst default-hints ctx wrld state)translate-hints+19574,846167
(defun translate-override-hints (name-tree lst ctx wrld state)translate-override-hints19583,846551
(defun@par apply-override-hint1apply-override-hint119598,847162
(defun@par apply-override-hintapply-override-hint19711,851722
(defun@par apply-override-hintsapply-override-hints19734,852952
(defun@par eval-and-translate-hint-expressioneval-and-translate-hint-expression19757,853735
(deflabel goal-specgoal-spec20007,865666
(deflabel hints-and-the-waterfallhints-and-the-waterfall20114,869993
(deflabel hintshints20317,881905
(deflabel clause-identifierclause-identifier21059,917791
(deflabel computed-hintscomputed-hints21112,919841
(deflabel using-computed-hints-1using-computed-hints-121265,928142
(deflabel using-computed-hints-2using-computed-hints-221316,929363
(deflabel using-computed-hints-3using-computed-hints-321421,933601
(deflabel using-computed-hints-4using-computed-hints-421541,938576
(deflabel using-computed-hints-5using-computed-hints-521686,944690
(deflabel using-computed-hints-6using-computed-hints-621750,947051
(deflabel using-computed-hints-7using-computed-hints-722006,957230
(deflabel using-computed-hints-8using-computed-hints-822237,966461
(deflabel using-computed-hintsusing-computed-hints22279,968357
(defmacro ttags-seen ()ttags-seen22385,972920
(defrec certify-book-infocertify-book-info22443,975452
(defun active-book-name (wrld state)active-book-name22447,975547
(defrec deferred-ttag-notedeferred-ttag-note22458,976029
(defun fms-to-standard-co (str alist state evisc-tuple)fms-to-standard-co22462,976103
(defun print-ttag-note (val active-book-name include-bookp deferred-p state)print-ttag-note22469,976338
(defun show-ttag-notes1 (notes state)show-ttag-notes122524,978991
(defun show-ttag-notes-fn (state)show-ttag-notes-fn22536,979492
(defmacro show-ttag-notes ()show-ttag-notes22553,980291
(defun set-deferred-ttag-notes (val state)set-deferred-ttag-notes22557,980391
(defun ttags-from-deferred-ttag-notes1 (notes)ttags-from-deferred-ttag-notes122644,984045
(defun ttags-from-deferred-ttag-notes (notes)ttags-from-deferred-ttag-notes22654,984422
(defun print-deferred-ttag-notes-summary (state)print-deferred-ttag-notes-summary22657,984522
(defun notify-on-defttag (val active-book-name include-bookp state)notify-on-defttag22674,985296
(defun ttag-allowed-p (ttag ttags active-book-name acc)ttag-allowed-p22711,986823
(defun chk-acceptable-ttag1 (val active-book-name ttags-allowed ttags-seenchk-acceptable-ttag122735,987811
(defun chk-acceptable-ttag (val include-bookp ctx wrld state)chk-acceptable-ttag22801,991130
(defun chk-acceptable-ttags2 (ttag filenames ttags-allowed ttags-seenchk-acceptable-ttags222816,991614
(defun chk-acceptable-ttags1 (vals active-book-name ttags-allowed ttags-seenchk-acceptable-ttags122832,992555
(defun chk-acceptable-ttags (vals include-bookp ctx wrld state)chk-acceptable-ttags22861,994247
(defun chk-table-nil-args (op bad-arg bad-argn ctx state)chk-table-nil-args22877,994992
(defun chk-table-guard (name key val ctx wrld state)chk-table-guard22889,995397
(defun chk-table-guards-rec (name alist ctx pair wrld state)chk-table-guards-rec22931,997197
(defun chk-table-guards (name alist ctx wrld state)chk-table-guards22945,997889
(defun put-assoc-equal-fast (name val alist)put-assoc-equal-fast22958,998513
(defun global-set? (var val wrld old-val)global-set?22970,998934
(defun cltl-def-from-name2 (fn stobj-function axiomatic-p wrld)cltl-def-from-name222975,999046
(defrec absstobj-infoabsstobj-info22998,999967
(defun cltl-def-from-name1 (fn stobj-function axiomatic-p wrld)cltl-def-from-name123002,1000023
(defun cltl-def-from-name (fn wrld)cltl-def-from-name23027,1001137
(defun table-cltl-cmd (name key val op ctx wrld)table-cltl-cmd23039,1001599
(defun table-fn1 (name key val op term ctx wrld state event-form)table-fn123126,1006047
(defun table-fn (name args state event-form)table-fn23315,1015077
(defun set-override-hints-fn (lst at-end ctx wrld state)set-override-hints-fn23417,1019494

prove.lisp,21496
(defun abbreviationp1 (lambda-flg vars term2)abbreviationp137,1383
(defun abbreviationp1-lst (lambda-flg vars lst)abbreviationp1-lst55,2103
(defun abbreviationp (lambda-flg vars term2)abbreviationp63,2362
(defun all-vars-bag (term ans)all-vars-bag76,2858
(defun all-vars-bag-lst (lst ans)all-vars-bag-lst81,3012
(defun find-abbreviation-lemma (term geneqv lemmas ens wrld)find-abbreviation-lemma87,3175
(defun expand-abbreviations-with-lemma (term geneqvexpand-abbreviations-with-lemma122,4780
(defun expand-abbreviations (term alist geneqv fns-to-be-ignored-by-rewriteexpand-abbreviations150,5859
(defun expand-abbreviations-lst (lst alist geneqv-lstexpand-abbreviations-lst453,20221
(defun and-orp (term bool)and-orp473,21210
(defun find-and-or-lemma (term bool lemmas ens wrld)find-and-or-lemma484,21540
(defun expand-and-or (term bool fns-to-be-ignored-by-rewrite ens wrld stateexpand-and-or516,23118
(defun clausify-input1 (term bool fns-to-be-ignored-by-rewrite ens wrld stateclausify-input1623,28010
(defun clausify-input1-lst (lst fns-to-be-ignored-by-rewrite ens wrld stateclausify-input1-lst696,31558
(defun clausify-input (term fns-to-be-ignored-by-rewrite ens wrld state ttreeclausify-input716,32544
(defun expand-some-non-rec-fns-in-clauses (fns clauses wrld)expand-some-non-rec-fns-in-clauses742,33915
(defun no-op-histp (hist)no-op-histp761,34708
(defun expand-any-final-implies1 (term wrld)expand-any-final-implies1797,36294
(defun expand-any-final-implies1-lst (term-lst wrld)expand-any-final-implies1-lst829,37541
(defun expand-any-final-implies (cl wrld)expand-any-final-implies838,37783
(defun rw-cache-state (wrld)rw-cache-state861,38637
(defmacro make-rcnst (ens wrld &rest args)make-rcnst866,38807
(defun cheap-type-alist-and-pot-lst (cl ens wrld state)cheap-type-alist-and-pot-lst897,40189
(defconst *tau-ttree**tau-ttree*933,42001
(defun tau-clausep (clause ens wrld state calist)tau-clausep938,42132
(defun tau-clausep-lst-rec (clauses ens wrld ans ttree state calist)tau-clausep-lst-rec968,43160
(defun tau-clausep-lst (clauses ens wrld ans ttree state calist)tau-clausep-lst995,44156
(defun preprocess-clause (cl hist pspv wrld state step-limit)preprocess-clause1007,44567
(defun tilde-*-preprocess-phrase (ttree)tilde-*-preprocess-phrase1208,55184
(defun tilde-*-raw-preprocess-phrase (ttree punct)tilde-*-raw-preprocess-phrase1234,56087
(defun preprocess-clause-msg1 (signal clauses ttree pspv state)preprocess-clause-msg11259,56913
(defun more-than-simplifiedp (hist)more-than-simplifiedp1317,59440
(defun delete-assoc-eq-lst (lst alist)delete-assoc-eq-lst1337,60301
(defun delete-assumptions-1 (recs only-immediatep)delete-assumptions-11345,60572
(defun delete-assumptions (ttree only-immediatep)delete-assumptions1369,61677
(defun save-and-print-acl2p-checkpoint (cl-id prettyified-clausesave-and-print-acl2p-checkpoint1389,62381
(defun find-the-first-checkpoint (h checkpoint-processors)find-the-first-checkpoint1453,65470
(defun acl2p-push-clause-printing (cl hist pspv wrld state)acl2p-push-clause-printing1479,66541
(defun@par push-clause (cl hist pspv wrld state)push-clause1520,68260
(defun push-clause-msg1-abort (cl-id ttree pspv state)push-clause-msg1-abort1870,83741
(defun push-clause-msg1 (cl-id signal clauses ttree pspv state)push-clause-msg11910,85411
(deflabel otf-flgotf-flg1934,86335
(defun clause-set-subsumes-1 (init-subsumes-count cl-set1 cl-set2 acc)clause-set-subsumes-11978,88178
(defun clause-set-subsumes (init-subsumes-count cl-set1 cl-set2)clause-set-subsumes1992,88921
(defun preprocess-clause? (cl hist pspv wrld state step-limit)preprocess-clause?2005,89390
(defun apply-use-hint-clauses (temp clauses pspv wrld state step-limit)apply-use-hint-clauses2012,89736
(defun apply-cases-hint-clause (temp cl pspv wrld)apply-cases-hint-clause2125,94886
(defun term-list-listp (l w)term-list-listp2161,96157
(defun non-term-listp-msg (x w)non-term-listp-msg2168,96323
(defun non-term-list-listp-msg (l w)non-term-list-listp-msg2185,96769
(defun eval-clause-processor (clause term stobjs-out ctx state)eval-clause-processor2203,97242
(defun eval-clause-processor@par (clause term stobjs-out ctx state)eval-clause-processor@par2264,99856
(defun apply-top-hints-clause1 (temp cl-id cl pspv wrld state step-limit)apply-top-hints-clause12339,103130
(defun@par apply-top-hints-clause (cl-id cl hist pspv wrld ctx state step-limit)apply-top-hints-clause2622,115943
(defun tilde-@-lmi-phrase (lmi-lst k event-names)tilde-@-lmi-phrase2715,120691
(defun or-hit-msg (gag-mode-only-p cl-id ttree)or-hit-msg2792,124085
(defun apply-top-hints-clause-msg1apply-top-hints-clause-msg12815,125265
(defun previous-process-was-speciousp (hist)previous-process-was-speciousp3022,135320
(defconst *preprocess-clause-ledge**preprocess-clause-ledge*3120,140330
(defmacro initialize-pspv-for-gag-mode (pspv)initialize-pspv-for-gag-mode3151,141576
(defun waterfall-update-gag-state (cl-id clause proc signal ttree pspvwaterfall-update-gag-state3226,144790
(defun waterfall-update-gag-state@par (cl-id clause proc signal ttree pspv state)waterfall-update-gag-state@par3406,153957
(defun@par record-gag-state (gag-state state)record-gag-state3415,154291
(defun@par gag-state-exiting-cl-id (signal cl-id pspv state)gag-state-exiting-cl-id3421,154478
(defun remove-pool-lst-from-gag-state (pool-lst gag-state state)remove-pool-lst-from-gag-state3496,158438
(defun pop-clause-update-gag-state-pop (pool-lsts gag-state msgs msg-p state)pop-clause-update-gag-state-pop3550,160853
(defun gag-mode-jppl-flg (gag-state)gag-mode-jppl-flg3571,161530
(defmacro splitter-output ()splitter-output3592,162366
(defdoc splittersplitter3608,163056
(defmacro set-splitter-output (val)set-splitter-output3764,170386
(defun waterfall-msg1waterfall-msg13798,172019
(defmacro io?-prove-cw (vars body &rest keyword-args)io?-prove-cw3859,174232
(defmacro io?-prove@par (&rest rst)io?-prove@par3871,174513
(defun waterfall-print-clause-body (cl-id clause state)waterfall-print-clause-body3878,174672
(defmacro waterfall-print-clause-id-fmt1-call (cl-id)waterfall-print-clause-id-fmt1-call3892,175140
(defmacro waterfall-print-clause-id-fmt1-call@par (cl-id)waterfall-print-clause-id-fmt1-call@par3905,175516
(defmacro waterfall-print-clause-id (cl-id)waterfall-print-clause-id3918,175914
(defmacro waterfall-print-clause-id@par (cl-id)waterfall-print-clause-id@par3925,176112
(defproxy print-clause-id-okp (*) => *)print-clause-id-okp3966,178163
(defun print-clause-id-okp-builtin (cl-id)print-clause-id-okp-builtin3968,178204
(defun@par waterfall-print-clause (suppress-print cl-id clause state)waterfall-print-clause3976,178406
(defun some-parent-is-checkpointp (hist state)some-parent-is-checkpointp3997,179285
(defun@par waterfall-msgwaterfall-msg4005,179564
(defun put-ttree-into-pspv (ttree pspv)put-ttree-into-pspv4093,183584
(defun set-cl-ids-of-assumptions1 (recs cl-id)set-cl-ids-of-assumptions14098,183774
(defun set-cl-ids-of-assumptions (ttree cl-id)set-cl-ids-of-assumptions4108,184243
(defun collect-assumptions1 (recs only-immediatep ans)collect-assumptions14127,185130
(defun collect-assumptions (ttree only-immediatep)collect-assumptions4145,185851
(defun sublis-var-lst-lst (alist clauses)sublis-var-lst-lst4169,186990
(defun add-segments-to-clause (clause segments)add-segments-to-clause4174,187178
(defun split-initial-extra-info-lits (cl hyps-rev)split-initial-extra-info-lits4180,187413
(defun conjoin-clause-to-clause-set-extra-info1 (tags-rev cl0 cl cl-setconjoin-clause-to-clause-set-extra-info14187,187686
(defun conjoin-clause-to-clause-set-extra-info (cl cl-set)conjoin-clause-to-clause-set-extra-info4233,189795
(defun conjoin-clause-sets-extra-info (cl-set1 cl-set2)conjoin-clause-sets-extra-info4253,190866
(defun maybe-add-extra-info-lit (debug-info term clause wrld)maybe-add-extra-info-lit4270,191669
(defun conjoin-clause-sets+ (debug-info cl-set1 cl-set2)conjoin-clause-sets+4279,192026
(defconst *equality-aliases**equality-aliases*4283,192206
(defun term-equated-to-constant (term)term-equated-to-constant4290,192410
(defun simplify-clause-for-term-equal-const-1 (var const cl)simplify-clause-for-term-equal-const-14301,192738
(defun simplify-clause-for-term-equal-const (var const cl)simplify-clause-for-term-equal-const4321,193648
(defun add-literal-smart (lit cl at-end-flg)add-literal-smart4330,193903
(defun guard-clauses (term debug-info stobj-optp clause wrld ttree)guard-clauses4349,194554
(defun guard-clauses-lst (lst debug-info stobj-optp clause wrld ttree)guard-clauses-lst4599,205948
(defun linked-variables1 (vars direct-links changedp direct-links0)linked-variables14614,206451
(defun linked-variables (vars direct-links)linked-variables4631,207171
(defun contains-constrained-constantp (term wrld)contains-constrained-constantp4692,210541
(defun contains-constrained-constantp-lst (lst wrld)contains-constrained-constantp-lst4706,211185
(defun disvar-type-alist1 (vars type-alist wrld)disvar-type-alist14714,211466
(defun collect-all-vars (lst)collect-all-vars4722,211840
(defun disvar-type-alist (type-alist term wrld)disvar-type-alist4726,211967
(defun unencumber-type-alist (type-alist term rewrittenp wrld)unencumber-type-alist4746,212831
(defun unencumber-assumption (assn wrld)unencumber-assumption4789,214837
(defun unencumber-assumptions (assumptions wrld ans)unencumber-assumptions4859,217065
(defun dumb-type-alist-implicationp1 (type-alist1 type-alist2 seen)dumb-type-alist-implicationp14896,218652
(defun dumb-type-alist-implicationp2 (type-alist1 type-alist2)dumb-type-alist-implicationp24908,219283
(defun dumb-type-alist-implicationp (type-alist1 type-alist2)dumb-type-alist-implicationp4914,219563
(defun partition-according-to-assumption-term (assumptions alist)partition-according-to-assumption-term4978,222941
(defun exists-assumption-with-weaker-type-alist (assumption assumptions i)exists-assumption-with-weaker-type-alist5000,223832
(defun add-assumption-with-weak-type-alist (assumption assumptions ans)add-assumption-with-weak-type-alist5018,224619
(defun dumb-keep-assumptions-with-weakest-type-alists (assumptions kept)dumb-keep-assumptions-with-weakest-type-alists5043,225744
(defun dumb-assumption-subsumption1 (partitions ans)dumb-assumption-subsumption15078,227260
(defun dumb-assumption-subsumption (assumptions)dumb-assumption-subsumption5094,227786
(defun clausify-type-alist (type-alist cl ens w seen ttree)clausify-type-alist5111,228592
(defun clausify-assumption (assumption ens wrld)clausify-assumption5138,229831
(defun clausify-assumptions (assumptions ens wrld pairs ttree)clausify-assumptions5153,230232
(defun strip-assumption-terms (lst)strip-assumption-terms5171,230953
(defun add-splitters-to-ttree1 (assumnotes tag ttree)add-splitters-to-ttree15179,231212
(defun add-splitters-to-ttree (immediatep tag assumptions ttree)add-splitters-to-ttree5188,231526
(defun maybe-add-splitters-to-ttree (splitter-output immediatep tagmaybe-add-splitters-to-ttree5202,232006
(defun extract-and-clausify-assumptions (cl ttree only-immediatep ens wrldextract-and-clausify-assumptions5208,232260
(defun@par waterfall-step1 (processor cl-id clause hist pspv wrld statewaterfall-step15333,238754
(defun@par process-backtrack-hint (cl-id clause clauses processor new-histprocess-backtrack-hint5368,239889
(defun set-rw-cache-state-in-pspv (pspv val)set-rw-cache-state-in-pspv5409,241803
(defun maybe-set-rw-cache-state-disabled (pspv)maybe-set-rw-cache-state-disabled5417,242115
(defun maybe-set-rw-cache-state-enabled (pspv)maybe-set-rw-cache-state-enabled5425,242397
(defun accumulate-rw-cache-into-pspv (processor ttree pspv)accumulate-rw-cache-into-pspv5433,242678
(defun erase-rw-cache-from-pspv (pspv)erase-rw-cache-from-pspv5463,244154
(defconst *simplify-clause-ledge**simplify-clause-ledge*5484,245048
(defconst *simplify-clause-ledge-complement**simplify-clause-ledge-complement*5487,245141
(defun@par waterfall-step-cleanup (processor cl-id clause hist wrld statewaterfall-step-cleanup5491,245281
(defun@par waterfall-step (processor cl-id clause hist pspv wrld ctx statewaterfall-step5651,252201
(defun@par find-applicable-hint-settings1find-applicable-hint-settings15823,260845
(defun@par find-applicable-hint-settings (cl-id clause hist pspv ctx hints wrldfind-applicable-hint-settings6006,270100
(defun@par thanks-for-the-hint (goal-already-printed-p hint-settings state)thanks-for-the-hint6020,270789
(defun lmi-name-or-rune (lmi)lmi-name-or-rune6088,273813
(defun enabled-lmi-names1 (ens pairs)enabled-lmi-names16101,274213
(defun enabled-lmi-names (ens lmi-lst wrld)enabled-lmi-names6116,274755
(defdoc using-enabled-rulesusing-enabled-rules6137,275463
(defun@par maybe-warn-for-use-hint (pspv cl-id ctx wrld state)maybe-warn-for-use-hint6212,278479
(defun@par maybe-warn-about-theory-simple (ens1 ens2 ctx wrld state)maybe-warn-about-theory-simple6235,279328
(defun@par maybe-warn-about-theory-from-rcnsts (rcnst1 rcnst2 ctx ens wrldmaybe-warn-about-theory-from-rcnsts6246,279841
(defun waterfall-or-hit-msg-a (cl-id user-hinti d-cl-id i branch-cnt state)waterfall-or-hit-msg-a6292,281931
(defun waterfall-or-hit-msg-b (cl-id d-cl-id branch-cnt state)waterfall-or-hit-msg-b6328,283263
(defun tilde-*-or-hit-summary-phrase1 (summary)tilde-*-or-hit-summary-phrase16348,284149
(defun tilde-*-or-hit-summary-phrase (summary)tilde-*-or-hit-summary-phrase6361,284622
(defun waterfall-or-hit-msg-c (parent-cl-id results revert-d-cl-id cl-id summarywaterfall-or-hit-msg-c6374,285055
(defun term-difficulty1 (term wrld n)term-difficulty16443,288179
(defun term-difficulty1-lst (lst wrld n)term-difficulty1-lst6457,288782
(defun term-difficulty (term wrld)term-difficulty6463,288970
(defun clause-difficulty (cl wrld)clause-difficulty6471,289315
(defun clause-set-difficulty (cl-set wrld)clause-set-difficulty6476,289433
(defun pool-difficulty (element0 pool wrld)pool-difficulty6485,289793
(defun how-many-to-be-proved (element0 pool)how-many-to-be-proved6496,290196
(defun pick-best-pspv-for-waterfall0-or-hit1pick-best-pspv-for-waterfall0-or-hit16508,290590
(defun pick-best-pspv-for-waterfall0-or-hit (results pspv0 wrld)pick-best-pspv-for-waterfall0-or-hit6561,293194
(defun change-or-hit-history-entry (i hist cl-id)change-or-hit-history-entry6595,294606
(defun@par pair-cl-id-with-hint-setting (cl-id hint-settings)pair-cl-id-with-hint-setting6647,296722
(defun apply-reorder-hint-front (indices len clauses acc)apply-reorder-hint-front6680,298405
(defun apply-reorder-hint-back (indices current-index clauses acc)apply-reorder-hint-back6687,298649
(defun filter-> (lst max)filter->6694,299006
(defun@par apply-reorder-hint (pspv clauses ctx state)apply-reorder-hint6701,299191
(defun pspv-equal-except-for-tag-tree-and-pool (x y)pspv-equal-except-for-tag-tree-and-pool6732,300543
(defun list-extensionp-aux (rev-base rev-extension)list-extensionp-aux6764,302020
(defun list-extensionp (base extension)list-extensionp6775,302348
(defun find-list-extensions (base extension acc)find-list-extensions6784,302571
(defun combine-pspv-pools (base x y debug-pspv)combine-pspv-pools6791,302790
(defun combine-pspv-tag-trees (x y)combine-pspv-tag-trees6802,303101
(defun print-pspvs (base x y debug-pspv)print-pspvs6811,303402
(defun combine-prove-spec-vars (base x y ctx debug-pspv signal1 signal2)combine-prove-spec-vars6820,303593
(defun speculative-execution-valid (x y)speculative-execution-valid6876,305567
(defun abort-will-occur-in-pool (pool)abort-will-occur-in-pool6891,306107
(defrec maybe-to-be-proved-by-inductionmaybe-to-be-proved-by-induction6933,308269
(defun convert-maybes-to-tobe-subgoals (pool)convert-maybes-to-tobe-subgoals6943,308546
(defun convert-maybes-to-tobes (pool)convert-maybes-to-tobes6958,309155
(defun convert-maybes-to-tobes-in-pspv (pspv)convert-maybes-to-tobes-in-pspv7026,312151
(defun erase-rw-cache-any-tag-from-pspv (pspv)erase-rw-cache-any-tag-from-pspv7035,312496
(defun restore-rw-cache-state-in-pspv (new-pspv old-pspv)restore-rw-cache-state-in-pspv7046,312862
(defvar *waterfall-parallelism-timings-ht-alist* nil*waterfall-parallelism-timings-ht-alist*7060,313616
(defvar *waterfall-parallelism-timings-ht* nil*waterfall-parallelism-timings-ht*7066,313910
(defun setup-waterfall-parallelism-ht-for-name (name)setup-waterfall-parallelism-ht-for-name7074,314296
(defun clear-current-waterfall-parallelism-ht ()clear-current-waterfall-parallelism-ht7098,315460
(defun flush-waterfall-parallelism-hashtables ()flush-waterfall-parallelism-hashtables7104,315593
(defun save-waterfall-timings-for-cl-id (key value)save-waterfall-timings-for-cl-id7112,315821
(defun lookup-waterfall-timings-for-cl-id (key)lookup-waterfall-timings-for-cl-id7119,316041
(defmacro waterfall1-wrapper (form)waterfall1-wrapper7127,316323
(defparameter *acl2p-starting-proof-time* 0.0d0)*acl2p-starting-proof-time*7138,316778
(defun waterfall1-wrapper@par-before (cl-id state)waterfall1-wrapper@par-before7141,316839
(defun waterfall1-wrapper@par-after (cl-id start-time state)waterfall1-wrapper@par-after7178,318379
(defmacro waterfall1-wrapper@par (&rest form)waterfall1-wrapper@par7203,319373
(defun increment-waterfall-parallelism-counter (abbreviated-symbol)increment-waterfall-parallelism-counter7216,319826
(defun halves-with-length (clauses)halves-with-length7241,320597
(defun@par waterfall1waterfall17256,321112
(defun@par waterfall0-with-hint-settingswaterfall0-with-hint-settings7337,324697
(defun@par waterfall0 (ledge cl-id clause hist pspv hints ens wrld ctx statewaterfall07380,326518
(defun@par waterfall0-or-hit (ledge cl-id clause hist pspv hints ens wrld ctxwaterfall0-or-hit7685,339184
(defun waterfall1-lst (n parent-cl-id clauses hist pspv jppl-flgwaterfall1-lst7898,348783
(defun waterfall1-lst@par-serial (n parent-cl-id clauses hist pspv jppl-flgwaterfall1-lst@par-serial7973,351650
(defun waterfall1-tree@par-pseudo-parallel (n parent-cl-id clauses hist pspvwaterfall1-tree@par-pseudo-parallel8037,354388
(defun waterfall1-tree@par-parallel (n parent-cl-id clauses hist pspv jppl-flgwaterfall1-tree@par-parallel8202,362384
(defun waterfall1-lst@par (n parent-cl-id clauses hist pspv jppl-flgwaterfall1-lst@par8417,373135
(defun waterfall (forcing-round pool-lst x pspv hints ens wrld ctx statewaterfall8556,378989
(defun some-pool-member-subsumes (pool clause-set)some-pool-member-subsumes8656,383838
(defun add-to-pop-historyadd-to-pop-history8672,384543
(defun pop-clause1 (pool pop-history)pop-clause18718,386687
(defun make-defthm-forms-for-byes (byes wrld)make-defthm-forms-for-byes8794,390173
(defun pop-clause-msg1 (forcing-round lst jppl-flg prev-action gag-state msg-ppop-clause-msg18805,390575
(defun pop-clause-msg (forcing-round pop-history jppl-flg pspv state)pop-clause-msg8971,398660
(defun subsumed-clause-ids-from-pop-history (forcing-round pop-history)subsumed-clause-ids-from-pop-history8996,399547
(defun increment-proof-tree-pop-clause (forcing-round pop-history state)increment-proof-tree-pop-clause9010,400125
(defun pop-clause (forcing-round pspv jppl-flg state)pop-clause9023,400708
(defun tilde-@-assumnotes-phrase-lst (lst wrld)tilde-@-assumnotes-phrase-lst9059,402341
(defun tilde-*-assumnotes-column-phrase (assumnotes wrld)tilde-*-assumnotes-column-phrase9111,405171
(defun tilde-@-assumnotes-phrase-lst-gag-mode (lst acc)tilde-@-assumnotes-phrase-lst-gag-mode9118,405388
(defun tilde-*-assumnotes-column-phrase-gag-mode (assumnotes)tilde-*-assumnotes-column-phrase-gag-mode9158,407267
(defun process-assumptions-msg1 (forcing-round n pairs state)process-assumptions-msg19165,407496
(defun process-assumptions-msg (forcing-round n0 n pairs state)process-assumptions-msg9202,408977
(deflabel forcing-roundforcing-round9249,411209
(deflabel failurefailure9384,418560
(deflabel failed-forcingfailed-forcing9430,421203
(defun count-assumptions (ttree)count-assumptions9577,428226
(defun add-type-alist-runes-to-ttree1 (type-alist runes)add-type-alist-runes-to-ttree19584,428412
(defun add-type-alist-runes-to-ttree (type-alist ttree)add-type-alist-runes-to-ttree9592,428684
(defun process-assumptions-ttree (assns ttree)process-assumptions-ttree9601,429105
(defun process-assumptions (forcing-round pspv wrld state)process-assumptions9613,429524
(defun do-not-induct-msg (forcing-round pool-lst state)do-not-induct-msg9693,432878
(defun prove-loop2 (forcing-round pool-lst clauses pspv hints ens wrld ctxprove-loop29720,433810
(defun prove-loop1 (forcing-round pool-lst clauses pspv hints ens wrld ctxprove-loop19827,438595
(defun print-pstack-and-gag-state (state)print-pstack-and-gag-state9838,439001
(defun prove-loop0 (clauses pspv hints ens wrld ctx state)prove-loop09869,440332
(defmacro bind-acl2-time-limit (form)bind-acl2-time-limit9894,441382
(defun prove-loop (clauses pspv hints ens wrld ctx state)prove-loop9917,442387
(defmacro make-pspv (ens wrld &rest args)make-pspv9949,443750
(defun chk-assumption-free-ttree (ttree ctx state)chk-assumption-free-ttree9973,444759
(defun prove (term pspv hints ens wrld ctx state)prove10025,447197

defuns.lisp,23404
(defconst *mutual-recursion-ctx-string**mutual-recursion-ctx-string*31,1307
(defun translate-bodies1 (non-executablep names bodies bindingstranslate-bodies134,1394
(defun chk-non-executable-bodies (names arglists bodies non-executablep ctxchk-non-executable-bodies112,4978
(defun translate-bodies (non-executablep names arglists bodies known-stobjs-lsttranslate-bodies148,6709
(defun chk-mutual-recursion-bad-names (lst names bodies)chk-mutual-recursion-bad-names179,8164
(defconst *chk-mutual-recursion-string**chk-mutual-recursion-string*187,8476
(defun chk-mutual-recursion1 (names bodies warnp ctx state)chk-mutual-recursion1196,8863
(defun chk-mutual-recursion (names bodies ctx state)chk-mutual-recursion216,9530
(defun ffnnamep-mod-mbe (fn term)ffnnamep-mod-mbe245,10735
(defun ffnnamep-mod-mbe-lst (fn l)ffnnamep-mod-mbe-lst264,11537
(defun putprop-recursivep-lst (names bodies wrld)putprop-recursivep-lst279,11955
(defrec tests-and-call (tests call) nil)tests-and-call307,13291
(defun all-calls (names term alist ans)all-calls316,13658
(defun all-calls-lst (names lst alist ans)all-calls-lst345,14963
(defun all-calls-alist (names alist ans)all-calls-alist354,15203
(defun termination-machine1 (tests calls ans)termination-machine1363,15528
(defun ffnnamesp-eq (fns term)ffnnamesp-eq383,16304
(defun ffnnamesp-eq-lst (fns l)ffnnamesp-eq-lst393,16685
(defun member-eq-all (a lst)member-eq-all401,16823
(defun termination-machine (names body alist tests ruler-extenders)termination-machine407,16918
(defun termination-machine-for-list (names bodies alist tests ruler-extenders)termination-machine-for-list514,21848
(defun termination-machines (names bodies ruler-extenders-lst)termination-machines522,22236
(defun proper-dumb-occur-as-output (x y)proper-dumb-occur-as-output537,22839
(defun always-tested-and-changedp (var pos t-machine)always-tested-and-changedp562,23997
(defun guess-measure (name defun-flg args pos t-machine ctx wrld state)guess-measure588,25059
(defun guess-measure-alist (names arglists measures t-machines ctx wrld state)guess-measure-alist644,28120
(defun remove-built-in-clauses (cl-set ens oncep-override wrld state ttree)remove-built-in-clauses679,29922
(defun length-exceedsp (lst n)length-exceedsp714,31407
(defun clean-up-clause-set (cl-set ens wrld ttree state)clean-up-clause-set719,31533
(defun measure-clause-for-branch (name tc measure-alist rel wrld)measure-clause-for-branch801,35292
(defun measure-clauses-for-fn1 (name t-machine measure-alist rel wrld)measure-clauses-for-fn1832,36427
(defun measure-clauses-for-fn (name t-machine measure-alist mp rel wrld)measure-clauses-for-fn846,37045
(defun measure-clauses-for-clique (names t-machines measure-alist mp rel wrld)measure-clauses-for-clique877,38160
(defun tilde-*-measure-phrase1 (alist wrld)tilde-*-measure-phrase1894,38868
(defun tilde-*-measure-phrase (alist wrld)tilde-*-measure-phrase902,39209
(defun find-?-measure (measure-alist)find-?-measure930,40209
(defun prove-termination (names t-machines measure-alist mp rel hints otf-flgprove-termination939,40512
(defun putprop-justification-lst (measure-alist subset-lst mp relputprop-justification-lst1142,50446
(defun union-equal-to-end (x y)union-equal-to-end1170,51570
(defun cross-tests-and-calls3 (tacs tacs-lst)cross-tests-and-calls31179,51827
(defun cross-tests-and-calls2 (tacs-lst1 tacs-lst2)cross-tests-and-calls21195,52696
(defun cross-tests-and-calls1 (tacs-lst-lst acc)cross-tests-and-calls11203,52955
(defun sublis-tests-rev (test-alist acc)sublis-tests-rev1212,53270
(defun all-calls-test-alist (names test-alist acc)all-calls-test-alist1230,54017
(defun cross-tests-and-calls (names top-test-alist top-calls tacs-lst-lst)cross-tests-and-calls1242,54423
(defun induction-machine-for-fn1 (names body alist test-alist callsinduction-machine-for-fn11309,57925
(defun induction-machine-for-fn1-lst (names bodies alist ruler-extenders accinduction-machine-for-fn1-lst1669,76151
(defun term-equated-to-constant-in-termlist (lst)term-equated-to-constant-in-termlist1693,77225
(defun simplify-tests (var const tests)simplify-tests1702,77526
(defun simplify-tests-and-calls (tc)simplify-tests-and-calls1723,78461
(defun simplify-tests-and-calls-lst (tc-list)simplify-tests-and-calls-lst1747,79416
(defun induction-machine-for-fn (names body ruler-extenders)induction-machine-for-fn1769,80133
(defun induction-machines (names bodies ruler-extenders-lst)induction-machines1791,81054
(defun putprop-induction-machine-lst (names bodies ruler-extenders-lstputprop-induction-machine-lst1811,81943
(defun quick-block-initial-settings (formals)quick-block-initial-settings1825,82497
(defun quick-block-info1 (var term)quick-block-info11830,82672
(defun quick-block-info2 (setting info1)quick-block-info21835,82821
(defun quick-block-settings (settings formals args)quick-block-settings1843,83047
(defun quick-block-down-t-machine (name settings formals t-machine)quick-block-down-t-machine1852,83480
(defun quick-block-info (name formals t-machine)quick-block-info1868,84109
(defun putprop-quick-block-info-lst (names t-machines wrld)putprop-quick-block-info-lst1886,84876
(deflabel subversive-recursionssubversive-recursions1902,85506
(deflabel subversive-inductionssubversive-inductions2056,93495
(defmacro big-mutrec (names)big-mutrec2066,93663
(defmacro update-w (condition new-w &optional retract-p)update-w2076,94068
(defun get-sig-fns1 (ee-lst)get-sig-fns12100,94916
(defun get-sig-fns (wrld)get-sig-fns2111,95339
(defun selected-all-fnnames-lst (formals subset actuals acc)selected-all-fnnames-lst2114,95422
(defun subversivep (fns t-machine formals-and-subset-alist wrld)subversivep2122,95722
(defun subversive-cliquep (fns t-machines formals-and-subset-alist wrld)subversive-cliquep2155,97064
(defun prove-termination-non-recursive (names bodies mp rel hints otf-flgprove-termination-non-recursive2190,98867
(defun prove-termination-recursive (names arglists measures t-machinesprove-termination-recursive2235,100687
(defun put-induction-info-recursive (names arglists col ttree measure-alistput-induction-info-recursive2278,102342
(defun put-induction-info (names arglists measures ruler-extenders-lst bodiesput-induction-info2330,104417
(defun destructure-definition (term install-body ens wrld ttree)destructure-definition2413,108408
(defun member-rewrite-rule-rune (rune lst)member-rewrite-rule-rune2470,110419
(defun replace-rewrite-rule-rune (rune rule lst)replace-rewrite-rule-rune2479,110712
(defun preprocess-hyp (hyp)preprocess-hyp2491,111130
(defun preprocess-hyps (hyps)preprocess-hyps2510,111945
(defun add-definition-rule-with-ttree (rune nume clique controller-alistadd-definition-rule-with-ttree2515,112101
(defun add-definition-rule (rune nume clique controller-alist install-body termadd-definition-rule2596,115787
(defun listof-standardp-macro (lst)listof-standardp-macro2605,116161
(defun putprop-body-lst (names arglists bodies normalizepsputprop-body-lst2620,116571
(defun type-set-implied-by-term1 (term tvar fvar)type-set-implied-by-term12909,132219
(defun type-set-implied-by-term (var not-flg term ens wrld ttree)type-set-implied-by-term2934,133239
(defun putprop-initial-type-prescriptions (names wrld)putprop-initial-type-prescriptions2954,134134
(defun map-returned-formals-via-formals (formals pockets returned-formals)map-returned-formals-via-formals3003,136324
(defun map-type-sets-via-formals (formals ts-lst returned-formals)map-type-sets-via-formals3034,137962
(defun vector-ts-union (ts-lst1 ts-lst2)vector-ts-union3050,138671
(defun map-cons-tag-trees (lst ttree)map-cons-tag-trees3059,138983
(defun type-set-and-returned-formals-with-rule1type-set-and-returned-formals-with-rule13068,139202
(defun type-set-and-returned-formals-with-rule (tp term type-alist ens wrldtype-set-and-returned-formals-with-rule3124,141482
(defun type-set-and-returned-formals-with-rulestype-set-and-returned-formals-with-rules3205,144698
(defun type-set-and-returned-formals (term type-alist ens wrld ttree)type-set-and-returned-formals3276,147662
(defun type-set-and-returned-formals-lsttype-set-and-returned-formals-lst3564,161696
(defun guess-type-prescription-for-fn-step (name body ens wrld ttree)guess-type-prescription-for-fn-step3582,162463
(defconst *clique-step-install-interval**clique-step-install-interval*3627,164525
(defun guess-and-putprop-type-prescription-lst-for-clique-stepguess-and-putprop-type-prescription-lst-for-clique-step3635,164804
(defun cleanse-type-prescriptionscleanse-type-prescriptions3699,167444
(defun guess-and-putprop-type-prescription-lst-for-cliqueguess-and-putprop-type-prescription-lst-for-clique3767,170690
(defun get-normalized-bodies (names wrld)get-normalized-bodies3818,173066
(defun putprop-type-prescription-lst (names subversive-p def-nume ens wrldputprop-type-prescription-lst3834,173686
(defun putprop-level-no-lst (names wrld)putprop-level-no-lst3979,179216
(defun primitive-recursive-argp (var term wrld)primitive-recursive-argp4005,180556
(defun primitive-recursive-callp (formals args wrld)primitive-recursive-callp4069,184157
(defun primitive-recursive-callsp (formals calls wrld)primitive-recursive-callsp4074,184389
(defun primitive-recursive-machinep (formals machine wrld)primitive-recursive-machinep4079,184621
(defun putprop-primitive-recursive-defunp-lst (names wrld)putprop-primitive-recursive-defunp-lst4096,185377
(defun make-controller-pocket (formals vars)make-controller-pocket4130,186922
(defun make-controller-alist1 (names wrld)make-controller-alist14143,187395
(defun make-controller-alist (names wrld)make-controller-alist4167,188544
(defun max-nume-exceeded-error (ctx)max-nume-exceeded-error4184,189400
(defun putprop-defun-runic-mapping-pairs1 (names def-nume tp-flg ind-flg wrld)putprop-defun-runic-mapping-pairs14193,189820
(defun putprop-defun-runic-mapping-pairs (names tp-flg wrld)putprop-defun-runic-mapping-pairs4230,191585
(defun eval-ground-subexpressions-lst-lst (lst-lst ens wrld state ttree)eval-ground-subexpressions-lst-lst4312,195799
(defun guard-clauses+ (term debug-info stobj-optp clause ens wrld state ttree)guard-clauses+4327,196382
(defun guard-clauses-for-body (hyp-segments body debug-info stobj-optp ensguard-clauses-for-body4336,196830
(defun guard-clauses-for-fn (name debug-p ens wrld state ttree)guard-clauses-for-fn4360,197846
(defun guard-clauses-for-clique (names debug-p ens wrld state ttree)guard-clauses-for-clique4430,200795
(defun print-verify-guards-msg (names col state)print-verify-guards-msg4451,201656
(defun collect-ideals (names wrld acc)collect-ideals4477,202560
(defun collect-non-ideals (names wrld)collect-non-ideals4483,202799
(defun collect-non-common-lisp-compliants (names wrld)collect-non-common-lisp-compliants4489,203038
(defun all-fnnames1-exec (flg x acc)all-fnnames1-exec4496,203358
(defmacro all-fnnames-exec (term)all-fnnames-exec4524,204550
(defun chk-common-lisp-compliant-subfunctionschk-common-lisp-compliant-subfunctions4527,204623
(defun chk-acceptable-verify-guards-formula (name x ctx wrld state)chk-acceptable-verify-guards-formula4556,206065
(defun chk-acceptable-verify-guards (name ctx wrld state)chk-acceptable-verify-guards4603,208208
(defun guard-obligation-clauses (x guard-debug ens wrld state)guard-obligation-clauses4694,212374
(defun guard-obligation (x guard-debug ctx state)guard-obligation4767,215437
(defun prove-guard-clauses-msg (names cl-set cl-set-ttree displayed-goalprove-guard-clauses-msg4847,219004
(defmacro verify-guards-formula (x &key guard-debug &allow-other-keys)verify-guards-formula4884,220593
(defun prove-guard-clauses (names hints otf-flg guard-debug ctx ens wrld state)prove-guard-clauses4932,222757
(defun verify-guards-fn1 (names hints otf-flg guard-debug ctx state)verify-guards-fn15032,227312
(defun verify-guards-fn (name state hints otf-flg guard-debug doc event-form)verify-guards-fn5268,237438
(defconst *super-defun-wart-table**super-defun-wart-table*5359,241091
(defun project-out-columns-i-and-j (i j table)project-out-columns-i-and-j5408,243773
(defconst *super-defun-wart-binding-alist**super-defun-wart-binding-alist*5414,243972
(defconst *super-defun-wart-stobjs-in-alist**super-defun-wart-stobjs-in-alist*5417,244078
(defun super-defun-wart-bindings (bindings)super-defun-wart-bindings5420,244186
(defun store-stobjs-ins (names stobjs-ins w)store-stobjs-ins5427,244474
(defun store-super-defun-warts-stobjs-in (names wrld)store-super-defun-warts-stobjs-in5433,244726
(defun collect-old-nameps (names wrld)collect-old-nameps5447,245210
(defun defuns-fn-short-cut (names docs pairs guards split-types-terms bodiesdefuns-fn-short-cut5453,245434
(defun print-defun-msg/collect-type-prescriptions (names wrld)print-defun-msg/collect-type-prescriptions5490,247236
(defun print-defun-msg/type-prescriptions1 (alist simp-phrase col state)print-defun-msg/type-prescriptions15514,248230
(defun print-defun-msg/type-prescriptions (names ttree wrld col state)print-defun-msg/type-prescriptions5556,250109
(defun simple-signaturep (fn wrld)simple-signaturep5599,251626
(defun all-simple-signaturesp (names wrld)all-simple-signaturesp5612,252106
(defun print-defun-msg/signatures1 (names wrld state)print-defun-msg/signatures15617,252290
(defun print-defun-msg/signatures (names wrld state)print-defun-msg/signatures5641,253185
(defun print-defun-msg (names ttree wrld col state)print-defun-msg5654,253646
(defun get-ignores (lst)get-ignores5682,254800
(defun get-ignorables (lst)get-ignorables5688,254964
(defun chk-all-stobj-names (lst msg ctx wrld state)chk-all-stobj-names5694,255137
(defun get-declared-stobj-names (edcls ctx wrld state)get-declared-stobj-names5710,255838
(defun get-stobjs-in-lst (lst ctx wrld state)get-stobjs-in-lst5751,257690
(defun chk-stobjs-out-bound (names bindings ctx state)chk-stobjs-out-bound5803,260303
(defun store-stobjs-out (names bindings w)store-stobjs-out5811,260638
(defun unparse-signature (x)unparse-signature5820,260931
(defun chk-defun-mode (defun-mode ctx state)chk-defun-mode5832,261358
(defun scan-to-cltl-command (wrld)scan-to-cltl-command5846,261842
(defconst *xargs-keywords**xargs-keywords*5860,262328
(defun plausible-dclsp1 (lst)plausible-dclsp15870,262652
(defun plausible-dclsp (lst)plausible-dclsp5889,263473
(defun dcl-fields1 (lst)dcl-fields15918,264834
(defun dcl-fields (lst)dcl-fields5925,265121
(defun strip-keyword-list (fields lst)strip-keyword-list5939,265639
(defun strip-dcls1 (fields lst)strip-dcls15953,266142
(defun strip-dcls (fields lst)strip-dcls5966,266756
(defun fetch-dcl-fields2 (field-names kwd-list acc)fetch-dcl-fields25984,267591
(defun fetch-dcl-fields1 (field-names lst)fetch-dcl-fields15994,268004
(defun fetch-dcl-fields (field-names lst)fetch-dcl-fields6005,268547
(defun fetch-dcl-field (field-name lst)fetch-dcl-field6016,269053
(defun set-equalp-eq (lst1 lst2)set-equalp-eq6034,269939
(defun non-identical-defp-chk-measures (name new-measures old-measuresnon-identical-defp-chk-measures6042,270243
(defun non-identical-defp (def1 def2 chk-measure-p wrld)non-identical-defp6096,272713
(defun identical-defp (def1 def2 chk-measure-p wrld)identical-defp6287,282403
(defun redundant-or-reclassifying-defunp0 (defun-mode symbol-classredundant-or-reclassifying-defunp06294,282644
(defun redundant-or-reclassifying-defunp (defun-mode symbol-classredundant-or-reclassifying-defunp6531,292820
(defun redundant-or-reclassifying-defunsp10 (defun-mode symbol-classredundant-or-reclassifying-defunsp106554,294201
(defun redundant-or-reclassifying-defunsp1 (defun-mode symbol-classredundant-or-reclassifying-defunsp16574,295081
(defun recover-defs-lst (fn wrld)recover-defs-lst6579,295370
(defun get-clique (fn wrld)get-clique6644,298637
(defun redundant-or-reclassifying-defunsp0 (defun-mode symbol-classredundant-or-reclassifying-defunsp06658,299233
(defun get-unnormalized-bodies (names wrld)get-unnormalized-bodies6706,302050
(defun strip-last-elements (lst)strip-last-elements6712,302299
(defun redundant-or-reclassifying-defunsp (defun-mode symbol-classredundant-or-reclassifying-defunsp6718,302500
(defun collect-when-cadr-eq (sym lst)collect-when-cadr-eq6869,310639
(defun all-programp (names wrld)all-programp6875,310853
(defun formal-position (var formals i)formal-position6952,314684
(defun make-posns (formals vars)make-posns6957,314843
(defun relevant-posns-term (fn formals term fns clique-alist posns)relevant-posns-term6964,315031
(defun relevant-posns-term-lst (fn formals lst fns clique-alist posns)relevant-posns-term-lst6985,315921
(defun relevant-posns-call (fn formals actuals i fns clique-alistrelevant-posns-call6992,316193
(defun relevant-posns-clique1 (fns arglists bodies all-fns ans)relevant-posns-clique17022,317584
(defun relevant-posns-clique-recur (fns arglists bodies clique-alist)relevant-posns-clique-recur7050,318810
(defun relevant-posns-clique-init (fns arglists guards split-types-termsrelevant-posns-clique-init7057,319198
(defun relevant-posns-lambdas (term ans)relevant-posns-lambdas7104,320989
(defun relevant-posns-lambdas-lst (termlist ans)relevant-posns-lambdas-lst7116,321393
(defun relevant-posns-merge (alist acc)relevant-posns-merge7123,321601
(defun relevant-posns-lambdas-top (bodies)relevant-posns-lambdas-top7135,322133
(defun relevant-posns-clique (fns arglists guards split-types-terms measuresrelevant-posns-clique7139,322295
(defun irrelevant-non-lambda-slots-clique2 (fn formals i posns acc)irrelevant-non-lambda-slots-clique27156,323245
(defun irrelevant-non-lambda-slots-clique1 (fns arglists clique-alist acc)irrelevant-non-lambda-slots-clique17164,323566
(defun irrelevant-non-lambda-slots-clique (fns arglists guardsirrelevant-non-lambda-slots-clique7176,324118
(defun tilde-*-irrelevant-formals-msg1 (slots)tilde-*-irrelevant-formals-msg17194,325136
(defun tilde-*-irrelevant-formals-msg (slots)tilde-*-irrelevant-formals-msg7202,325502
(defun chk-irrelevant-formals (fns arglists guards split-types-terms measureschk-irrelevant-formals7205,325634
(deflabel irrelevant-formalsirrelevant-formals7236,326979
(defun chk-logic-subfunctions (names0 names terms wrld str ctx state)chk-logic-subfunctions7305,330297
(defun get-non-classical-fns-from-list (names wrld fns-sofar)get-non-classical-fns-from-list7332,331554
(defmacro get-non-classical-fns (lst wrld)get-non-classical-fns7344,332075
(defun get-non-classical-fns-aux (lst wrld fns-sofar)get-non-classical-fns-aux7348,332191
(defun strip-missing-measures (lst accum)strip-missing-measures7363,332806
(defun chk-classical-measures (measures names ctx wrld state)chk-classical-measures7371,333063
(defun chk-no-recursive-non-classical (non-classical-fns names mp relchk-no-recursive-non-classical7391,333945
(defun union-collect-non-x (x lst)union-collect-non-x7428,335724
(defun translate-measures (terms ctx wrld state)translate-measures7433,335899
(defun redundant-predefined-error-msg (name)redundant-predefined-error-msg7465,337408
(defun chk-acceptable-defuns-redundancy (names ctx wrld state)chk-acceptable-defuns-redundancy7479,338082
(defun chk-acceptable-defuns-verify-guards-er (names ctx wrld state)chk-acceptable-defuns-verify-guards-er7566,341714
(defun chk-non-executablep (defun-mode non-executablep ctx state)chk-non-executablep7627,344467
(defun chk-acceptable-defuns0 (fives ctx wrld state)chk-acceptable-defuns07649,345357
(defun get-boolean-unambiguous-xargs-flg-lst (key lst default ctx state)get-boolean-unambiguous-xargs-flg-lst7705,347848
(defun chk-acceptable-defuns1 (names fives stobjs-in-lst defun-modechk-acceptable-defuns17713,348259
(defun conditionally-memoized-fns (fns memoize-table)conditionally-memoized-fns8011,361892
(defun chk-acceptable-defuns (lst ctx wrld state #+:non-standard-analysis std-p)chk-acceptable-defuns8029,362665
(deflabel XARGSXARGS8154,368736
(defmacro link-doc-to-keyword (name parent see)link-doc-to-keyword8303,375895
(defmacro link-doc-to (name parent see)link-doc-to8319,376220
(defun build-valid-std-usage-clause (arglist body)build-valid-std-usage-clause8488,383255
(defun verify-valid-std-usage (names arglists bodies hints otf-flgverify-valid-std-usage8496,383579
(defun union-eq1-rev (x y)union-eq1-rev8575,387185
(defun collect-hereditarily-constrained-fnnames (names wrld ans)collect-hereditarily-constrained-fnnames8585,387456
(defun putprop-hereditarily-constrained-fnnames-lst (names bodies wrld)putprop-hereditarily-constrained-fnnames-lst8599,388036
(defun defuns-fn1 (tuple ens big-mutrec names arglists docs pairs guardsdefuns-fn18640,390048
(defun defuns-fn0 (names arglists docs pairs guards measuresdefuns-fn08803,397473
(defun strip-non-hidden-package-names (known-package-alist)strip-non-hidden-package-names8854,399121
(defun in-package-fn (str state)in-package-fn8863,399545
(defun defstobj-functionsp (names embedded-event-lst)defstobj-functionsp8885,400388
(defun index-of-non-number (lst)index-of-non-number8949,404024
(defun non-std-error (fn index formals actuals)non-std-error8958,404230
(defun non-std-body (name formals body)non-std-body8967,404636
(defun non-std-def-lst (def-lst)non-std-def-lst8981,405129
(defun make-udf-insigs (names wrld)make-udf-insigs8996,405695
(defun intro-udf (insig wrld)intro-udf9005,405984
(defun intro-udf-lst1 (insigs wrld)intro-udf-lst19044,407379
(defun intro-udf-lst2 (insigs kwd-value-list-lst)intro-udf-lst29050,407584
(defun intro-udf-lst (insigs kwd-value-list-lst wrld)intro-udf-lst9088,409423
(defun defun-ctx (def-lst state event-form #+:non-standard-analysis std-p)defun-ctx9106,410241
(defun install-event-defuns (names event-form def-lst0 symbol-classinstall-event-defuns9124,410865
(defun defuns-fn (def-lst state event-form #+:non-standard-analysis std-p)defuns-fn9175,413012
(defun defun-fn (def state event-form #+:non-standard-analysis std-p)defun-fn9318,418817
(defun args-fn (name state)args-fn9333,419360
(defmacro args (name)args9420,423570
(defun make-verify-termination-def (old-def new-dcls wrld)make-verify-termination-def9441,424203
(defun make-verify-termination-defs-lst (defs-lst lst wrld)make-verify-termination-defs-lst9470,425455
(defun chk-acceptable-verify-termination1 (lst clique fn1 ctx wrld state)chk-acceptable-verify-termination19486,426245
(defun uniform-defun-modes (defun-mode clique wrld)uniform-defun-modes9524,428390
(defun chk-acceptable-verify-termination (lst ctx wrld state)chk-acceptable-verify-termination9538,428994
(defun verify-termination1 (lst state)verify-termination19609,432205
(defun verify-termination-boot-strap-fn (lst state event-form)verify-termination-boot-strap-fn9642,433646
(defmacro when-logic3 (str x)when-logic39673,434732
(defun verify-termination-fn (lst state)verify-termination-fn9682,434998
(defun fns-used-in-axioms (lst wrld ans)fns-used-in-axioms9709,436191
(defun check-out-instantiablep1 (fns wrld)check-out-instantiablep19735,437164
(defun check-out-instantiablep (wrld)check-out-instantiablep9744,437452

proof-checker-pkg.lisp,40
(defpkg "ACL2-PC" nil)"ACL2-PC"23,881

proof-checker-a.lisp,8305
(defmacro pc-value (sym)pc-value29,1271
(defmacro pc-assign (key val)pc-assign35,1467
(defun initialize-pc-acl2 (state)initialize-pc-acl244,1747
(defmacro state-stack ()state-stack55,2076
(defmacro old-ss ()old-ss58,2129
(defmacro ss-alist ()ss-alist63,2244
(defun define-global-name (var)define-global-name66,2291
(defmacro define-global (var)define-global71,2407
(define-global pc-prompt)pc-prompt78,2623
(define-global pc-prompt-depth-prefix)pc-prompt-depth-prefix79,2649
(define-global pc-print-macroexpansion-flg)pc-print-macroexpansion-flg80,2688
(define-global pc-print-prompt-and-instr-flg)pc-print-prompt-and-instr-flg82,2786
(defrec pc-statepc-state93,3346
(defconst *pc-state-fields-for-primitives**pc-state-fields-for-primitives*102,3459
(defmacro instruction (&optional state-stack-supplied-p)instruction105,3572
(defmacro goals (&optional state-stack-supplied-p)goals112,3790
(defmacro abbreviations (&optional state-stack-supplied-p)abbreviations119,3996
(defmacro local-tag-tree (&optional state-stack-supplied-p)local-tag-tree126,4218
(defmacro pc-ens (&optional state-stack-supplied-p)pc-ens133,4442
(defmacro tag-tree (&optional state-stack-supplied-p)tag-tree140,4650
(defrec goalgoal153,5192
(defconst *goal-fields**goal-fields*159,5279
(defmacro conc (&optional ss-supplied-p)conc162,5354
(defmacro hyps (&optional ss-supplied-p)hyps165,5449
(defmacro current-addr (&optional ss-supplied-p)current-addr168,5544
(defmacro goal-name (&optional ss-supplied-p)goal-name171,5655
(defmacro depends-on (&optional ss-supplied-p)depends-on174,5760
(defmacro make-official-pc-command (sym)make-official-pc-command177,5867
(defun intern-in-keyword-package (sym)intern-in-keyword-package181,6021
(defun make-pretty-pc-command (x)make-pretty-pc-command185,6142
(defun make-pretty-pc-instr (instr)make-pretty-pc-instr190,6308
(defmacro change-pc-state (pc-s &rest args)change-pc-state201,6703
(defun make-official-pc-instr (instr)make-official-pc-instr204,6787
(defun check-formals-length (formals args fn ctx state)check-formals-length221,7430
(defun check-&optional-and-&rest (formals state)check-&optional-and-&rest250,8843
(defun make-let-pairs-from-formals (formals arg)make-let-pairs-from-formals276,9986
(defun all-symbols (form)all-symbols292,10609
(defun all-symbols-list (x)all-symbols-list306,10959
(defun make-access-bindings (record-name record fields)make-access-bindings314,11099
(defun let-form-for-pc-state-vars (form)let-form-for-pc-state-vars320,11356
(defun check-field-names (formals ctx state)check-field-names332,11875
(defmacro print-no-change (&optional str alist (col '0))print-no-change342,12293
(defmacro print-no-change2 (&rest args)print-no-change2345,12399
(defun print-no-change-fn (str alist col state)print-no-change-fn349,12509
(defmacro maybe-update-instruction (instr pc-state-and-state)maybe-update-instruction369,13303
(defun add-pc-doc-header (command-type str)add-pc-doc-header378,13703
(defun remove-doc (command-type body)remove-doc389,13990
(defun pc-primitive-defun-form (raw-name name formals doc body)pc-primitive-defun-form396,14302
(defun pc-command-table-guard (key val wrld)pc-command-table-guard419,15194
(defmacro add-pc-command (name command-type)add-pc-command452,16071
(defmacro pc-command-type (name)pc-command-type455,16167
(defmacro print-no-change3 (&optional str alist (col '0))print-no-change3458,16273
(defun add-pc-command-1 (name command-type state)add-pc-command-1462,16412
(defun toggle-pc-macro-fn (name new-tp state)toggle-pc-macro-fn469,16616
(defun pc-meta-or-macro-defun (raw-name name formals doc body)pc-meta-or-macro-defun494,18233
(defun goal-names (goals)goal-names513,19018
(defun instructions-of-state-stack (ss acc)instructions-of-state-stack519,19162
(defmacro fms0 (str &optional alist col (evisc-tuple 'nil evisc-tuple-p))fms0528,19442
(defmacro with-output-forced (output-chan signature code)with-output-forced542,19986
(defun print-pc-prompt (state)print-pc-prompt566,20775
(defun pc-macroexpand (raw-instr state)pc-macroexpand577,21128
(defun find-goal (name goals)find-goal605,22419
(defun print-all-goals-proved-message (state)print-all-goals-proved-message612,22600
(defmacro when-goals (form)when-goals621,22874
(defmacro when-goals-trip (form)when-goals-trip626,22979
(defun current-immediate-deps (goal-name goal-names)current-immediate-deps632,23125
(defun goal-dependent-p (parent name)goal-dependent-p642,23550
(defun current-all-deps (goal-name goal-names)current-all-deps650,23766
(defun maybe-print-proved-goal-message (goal old-goals goals state)maybe-print-proved-goal-message660,24179
(defun accumulate-ttree-in-pc-state (pc-state state)accumulate-ttree-in-pc-state703,26335
(defun pc-process-assumptions (pc-ens ttree wrld state)pc-process-assumptions710,26628
(defun make-implication (assumptions concl)make-implication737,27407
(defun cl-set-to-implications (cl-set)cl-set-to-implications743,27557
(defun known-assumptions (type-alist assns)known-assumptions750,27792
(defun add-assumptions-to-top-goaladd-assumptions-to-top-goal767,28524
(defun unproved-goals (pc-state)unproved-goals794,29767
(defun make-pc-ens (pc-ens state)make-pc-ens802,29986
(defun initial-rcnst-from-ens (ens wrld splitter-output)initial-rcnst-from-ens807,30072
(defun make-new-goals-fixed-hyps (termlist hyps goal-name start-index)make-new-goals-fixed-hyps817,30496
(defun pc-single-step-primitive (instr state)pc-single-step-primitive830,30977
(defun maybe-print-macroexpansion (instr raw-instr state)maybe-print-macroexpansion1014,40452
(defun pc-single-step-1 (raw-instr state)pc-single-step-11033,41476
(defun union-lastn-pc-tag-trees (n ss acc)union-lastn-pc-tag-trees1105,45355
(defun pc-single-step (raw-instr state)pc-single-step1118,45751
(defconst *pc-complete-signal* 'acl2-pc-complete)*pc-complete-signal*1149,47365
(defmacro catch-throw-to-local-top-level (form)catch-throw-to-local-top-level1151,47416
(defun pc-main-loop (instr-list quit-conditions last-valuepc-main-loop1179,48411
(defun make-initial-goal (term)make-initial-goal1264,51976
(defun initial-state-stack (term raw-term event-name rule-classes pc-ens)initial-state-stack1272,52134
(defun event-name-and-types-and-raw-term (state-stack)event-name-and-types-and-raw-term1282,52526
(defmacro install-initial-state-stack (term raw-term event-name rule-classes)install-initial-state-stack1285,52648
(defun pc-main1 (instr-list quit-conditions pc-print-prompt-and-instr-flgpc-main11295,53051
(defun pc-main (term raw-term event-name rule-classes instr-listpc-main1302,53300
(defun pc-top (raw-term event-name rule-classes instr-list quit-conditions state)pc-top1308,53624
(defun illegal-fnp (x w)illegal-fnp1329,54338
(defun illegal-fnp-list (x w)illegal-fnp-list1343,54725
(defun verify-fn (raw-term raw-term-supplied-p event-name rule-classesverify-fn1349,54868
(defun print-unproved-goals-message (goals state)print-unproved-goals-message1403,56789
(defun state-stack-from-instructionsstate-stack-from-instructions1412,57176
(defun state-from-instructionsstate-from-instructions1423,57657
(defun print-pc-defthm (ev state)print-pc-defthm1431,57947
(defmacro print-pc-goal (&optional goal)print-pc-goal1442,58320
(defmacro print-pc-state (&optional pc-state)print-pc-state1467,59442
(defun proof-checkerproof-checker1486,60241
(deflabel proof-checker-commandsproof-checker-commands1571,64102
(deflabel macro-commandmacro-command1581,64405
(defmacro verify (&optional (raw-term 'nil raw-term-supplied-p)verify1608,65634
(deflabel instructionsinstructions1660,67491
(defun sublis-expr-non-quoteps (alist term)sublis-expr-non-quoteps2184,87602
(defun sublis-expr-non-quoteps-lst (alist lst)sublis-expr-non-quoteps-lst2202,88366
(defun invert-abbreviations-alist (alist)invert-abbreviations-alist2209,88568
(defun abbreviate (term abbreviations)abbreviate2216,88799
(defmacro untrans0 (term &optional iff-flg abbreviations)untrans02221,88957
(defun untrans0-lst-fn (termlist iff-flg abbreviations state)untrans0-lst-fn2227,89152
(defmacro untrans0-lst (termlist &optional iff-flg abbreviations)untrans0-lst2233,89382

defthm.lisp,29770
(defun remove-lambdas (term)remove-lambdas51,2105
(defun remove-lambdas-lst (termlist)remove-lambdas-lst61,2420
(defun interpret-term-as-rewrite-rule2 (name hyps lhs rhs wrld)interpret-term-as-rewrite-rule272,2676
(defun interpret-term-as-rewrite-rule1 (term equiv-okp ens wrld)interpret-term-as-rewrite-rule1107,3973
(defun interpret-term-as-rewrite-rule (name hyps term ens wrld)interpret-term-as-rewrite-rule144,5842
(defun non-recursive-fnnames (term ens wrld)non-recursive-fnnames191,7520
(defun non-recursive-fnnames-lst (lst ens wrld)non-recursive-fnnames-lst206,8212
(defun hide-lambdas1 (formals)hide-lambdas1217,8637
(defun hide-lambdas (lst)hide-lambdas227,8991
(defun variantp (term1 term2)variantp237,9369
(defun surrounding-fns1 (vars term fn acc)surrounding-fns1255,9841
(defun surrounding-fns-lst (vars term-list fn acc)surrounding-fns-lst283,10936
(defun surrounding-fns (vars term)surrounding-fns291,11154
(defun loop-stopper1 (alist vars lhs)loop-stopper1317,12154
(defun loop-stopper (lhs rhs)loop-stopper327,12573
(defun remove-irrelevant-loop-stopper-pairs (pairs vars)remove-irrelevant-loop-stopper-pairs502,22921
(defun put-match-free-value (match-free-value rune wrld)put-match-free-value520,23572
(defun free-vars-in-hyps (hyps bound-vars wrld)free-vars-in-hyps538,24207
(defun free-vars-in-hyps-simple (hyps bound-vars)free-vars-in-hyps-simple578,26063
(defun free-vars-in-fc-hyps (triggers hyps concls)free-vars-in-fc-hyps590,26581
(defun free-vars-in-hyps-considering-bind-free (hyps bound-vars wrld)free-vars-in-hyps-considering-bind-free602,26998
(defun all-vars-in-hyps (hyps)all-vars-in-hyps669,30005
(defun match-free-value (match-free hyps pat wrld)match-free-value700,31295
(defun match-free-fc-value (match-free hyps concls triggers wrld)match-free-fc-value710,31608
(defun rule-backchain-limit-lst (backchain-limit-lst hyps wrld flg)rule-backchain-limit-lst723,32205
(defun create-rewrite-rule (rune nume hyps equiv lhs rhs loop-stopper-lstcreate-rewrite-rule731,32546
(defun hyps-that-instantiate-free-vars (free-vars hyps)hyps-that-instantiate-free-vars773,34336
(defun maybe-one-way-unify (pat term alist)maybe-one-way-unify790,35023
(defun maybe-one-way-unify-lst (pat-lst term-lst alist)maybe-one-way-unify-lst808,35722
(defun maybe-one-way-unify-with-some (pat term-lst alist)maybe-one-way-unify-with-some815,36003
(defun maybe-subsumes (cl1 cl2 alist)maybe-subsumes824,36378
(defun subsumes-rewrite-rule (rule1 rule2 wrld)subsumes-rewrite-rule849,37587
(defun find-subsumed-rule-names (lst rule ens wrld)find-subsumed-rule-names901,39816
(defun find-subsuming-rule-names (lst rule ens wrld)find-subsuming-rule-names918,40669
(defun forced-hyps (lst)forced-hyps934,41477
(defun strip-top-level-nots-and-forces (hyps)strip-top-level-nots-and-forces943,41803
(defun free-variable-error? (token name ctx wrld state)free-variable-error?957,42386
(defun extend-geneqv-alist (var geneqv alist wrld)extend-geneqv-alist976,43434
(defun covered-geneqv-alist (term geneqv alist wrld)covered-geneqv-alist988,43848
(defun covered-geneqv-alist-lst (termlist geneqv-lst alist wrld)covered-geneqv-alist-lst1009,44746
(defun uncovered-equivs (geneqv covered-geneqv wrld)uncovered-equivs1019,45169
(defun uncovered-equivs-alist (term geneqv var-geneqv-alist var-geneqv-alist0uncovered-equivs-alist1029,45553
(defun uncovered-equivs-alist-lst (termlist geneqv-lst var-geneqv-alistuncovered-equivs-alist-lst1123,49818
(defun double-rewrite-opportunities (hyp-index hyps var-geneqv-alistdouble-rewrite-opportunities1143,50828
(defun show-double-rewrite-opportunities1 (location var-equivs-alistshow-double-rewrite-opportunities11244,56794
(defun show-double-rewrite-opportunities (hyp-var-equivs-counts-alist-pairsshow-double-rewrite-opportunities1279,58722
(defun irrelevant-loop-stopper-pairs (pairs vars)irrelevant-loop-stopper-pairs1301,59814
(defun chk-rewrite-rule-warnings (name match-free loop-stopper rule ctx enschk-rewrite-rule-warnings1313,60194
(defun chk-acceptable-rewrite-rule2 (name match-free loop-stopper hyps conclchk-acceptable-rewrite-rule21496,69429
(defun chk-acceptable-rewrite-rule1 (name match-free loop-stopper lst ctx enschk-acceptable-rewrite-rule11527,70890
(defun chk-acceptable-rewrite-rule (name match-free loop-stopper term ctx enschk-acceptable-rewrite-rule1546,71748
(defun add-rewrite-rule2 (rune nume hyps concl loop-stopper-lstadd-rewrite-rule21565,72732
(defun add-rewrite-rule1 (rune nume lst loop-stopper-lstadd-rewrite-rule11638,76389
(defun add-rewrite-rule (rune nume loop-stopper-lst termadd-rewrite-rule1659,77356
(deflabel linearlinear1675,78021
(defun expand-inequality-fncall1 (term)expand-inequality-fncall11814,85809
(defun expand-inequality-fncall (term)expand-inequality-fncall1837,86784
(defun all-vars-in-poly-lst (lst)all-vars-in-poly-lst1882,89018
(defun subbagp-eq (bag1 bag2)subbagp-eq1893,89369
(defun always-biggerp-data (term)always-biggerp-data1900,89568
(defun always-biggerp-data-lst (lst)always-biggerp-data-lst1908,89759
(defun always-biggerp (abd1 abd2)always-biggerp1916,89952
(defun no-element-always-biggerp (abd-lst abd)no-element-always-biggerp1940,91005
(defun maximal-terms1 (abd-lst abd-lst0 needed-vars)maximal-terms11950,91362
(defun maximal-terms (lst hyp-vars concl-vars)maximal-terms1965,91985
(defun collect-when-ffnnamesp (fns lst)collect-when-ffnnamesp2000,93721
(defun make-free-max-terms-msg1 (max-terms vars hyps)make-free-max-terms-msg12010,94026
(defun make-free-max-terms-msg (name max-terms vars hyps)make-free-max-terms-msg2037,95393
(defun external-linearize (term ens wrld state)external-linearize2053,95997
(defun bad-synp-hyp-msg-for-linear (max-terms hyps wrld)bad-synp-hyp-msg-for-linear2063,96240
(defun show-double-rewrite-opportunities-linear (hyps max-terms final-term nameshow-double-rewrite-opportunities-linear2072,96620
(defun chk-acceptable-linear-rule2chk-acceptable-linear-rule22093,97521
(defun chk-acceptable-linear-rule1 (name match-free trigger-terms lst ctx enschk-acceptable-linear-rule12232,105258
(defun chk-acceptable-linear-rule (name match-free trigger-terms term ctx enschk-acceptable-linear-rule2248,105937
(defun add-linear-rule3 (rune nume hyps concl max-termsadd-linear-rule32266,106792
(defun add-linear-rule2 (rune nume trigger-terms hyps concladd-linear-rule22308,108745
(defun add-linear-rule1 (rune nume trigger-terms lstadd-linear-rule12323,109448
(defun add-linear-rule (rune nume trigger-terms termadd-linear-rule2339,110251
(deflabel well-founded-relationwell-founded-relation2381,111647
(defun destructure-well-founded-relation-rule (term)destructure-well-founded-relation-rule2561,119582
(defun chk-acceptable-well-founded-relation-rule (name term ctx wrld state)chk-acceptable-well-founded-relation-rule2600,120899
(defun add-well-founded-relation-rule (rune nume term wrld)add-well-founded-relation-rule2637,122528
(deflabel built-in-clausebuilt-in-clause2649,123014
(defun chk-acceptable-built-in-clause-rule2 (name hyps concl ctx wrld state)chk-acceptable-built-in-clause-rule22786,128489
(defun chk-acceptable-built-in-clause-rule1 (name lst ctx wrld state)chk-acceptable-built-in-clause-rule12811,129588
(defun chk-acceptable-built-in-clause-rule (name term ctx wrld state)chk-acceptable-built-in-clause-rule2825,130115
(defun fn-and-maximal-level-no (term wrld fn max)fn-and-maximal-level-no2841,130847
(defun fn-and-maximal-level-no-lst (lst wrld fn max)fn-and-maximal-level-no-lst2867,132104
(defun built-in-clause-discriminator-fn (cl wrld)built-in-clause-discriminator-fn2876,132352
(defun all-fnnames-subsumer (cl wrld)all-fnnames-subsumer2882,132525
(defun make-built-in-clause-rules1 (rune nume clauses wrld)make-built-in-clause-rules12906,133958
(defun chk-initial-built-in-clauses (lst wrld good-lst some-badp)chk-initial-built-in-clauses2930,135135
(defun make-built-in-clause-rules (rune nume lst wrld)make-built-in-clause-rules2959,136375
(defun classify-and-store-built-in-clause-rules (lst pots wrld)classify-and-store-built-in-clause-rules2975,137041
(defun add-built-in-clause-rule (rune nume term wrld)add-built-in-clause-rule3021,139510
(deflabel compound-recognizercompound-recognizer3053,141010
(defun destructure-compound-recognizer (term)destructure-compound-recognizer3264,151242
(defun make-recognizer-tuple (rune nume parity fn var term ens wrld)make-recognizer-tuple3322,153795
(defun comment-on-new-recog-tuple1 (new-recog-tuple recognizer-alistcomment-on-new-recog-tuple13389,156783
(defun comment-on-new-recog-tuple (new-recog-tuple ctx ens wrld state)comment-on-new-recog-tuple3447,159882
(defun chk-acceptable-compound-recognizer-rule (name term ctx ens wrld state)chk-acceptable-compound-recognizer-rule3510,163011
(defun add-compound-recognizer-rule (rune nume term ens wrld)add-compound-recognizer-rule3567,165414
(deflabel forward-chainingforward-chaining3590,166473
(defun chk-triggers (name match-free hyps terms hyps-vars concls-vars ctx enschk-triggers3744,174739
(defun destructure-forward-chaining-term (term)destructure-forward-chaining-term3870,181943
(defun chk-acceptable-forward-chaining-rule (name match-free trigger-terms termchk-acceptable-forward-chaining-rule3911,183865
(defun putprop-forward-chaining-rules-lstputprop-forward-chaining-rules-lst3932,184611
(defun add-forward-chaining-rule (rune nume trigger-terms term match-free wrld)add-forward-chaining-rule3954,185576
(deflabel metameta3970,186313
(deflabel evaluator-restrictionsevaluator-restrictions4358,205814
(deflabel extended-metafunctionsextended-metafunctions4831,223133
(deflabel meta-extractmeta-extract5193,239409
(defun evaluator-clause/arglist (evfn formals x)evaluator-clause/arglist5520,255629
(defun evaluator-clause (evfn fn-args)evaluator-clause5534,256219
(defun evaluator-clauses1 (evfn fn-args-lst)evaluator-clauses15562,257216
(defun evaluator-clauses (evfn evfn-lst fn-args-lst)evaluator-clauses5567,257419
(defun cdrp (x term)cdrp5668,262899
(defun expand-eq-and-atom-term-lst (lst)expand-eq-and-atom-term-lst5684,263448
(defun normalize-alleged-evaluator-clause (clause)normalize-alleged-evaluator-clause5738,265849
(defun normalize-alleged-evaluator-clause-set (lst)normalize-alleged-evaluator-clause-set5748,266194
(defun shallow-clausify1 (lst)shallow-clausify15753,266408
(defun shallow-clausify (term)shallow-clausify5766,266790
(defun find-evfn-lst-in-clause (evfn cl)find-evfn-lst-in-clause5786,267659
(defun guess-evfn-lst-for-evfn (evfn cl-set)guess-evfn-lst-for-evfn5817,268743
(defun find-fn-in-clause (cl wrld)find-fn-in-clause5829,269224
(defun guess-fn-args-lst-for-evfn (cl-set wrld)guess-fn-args-lst-for-evfn5843,269740
(defun normalized-evaluator-cl-set (ev wrld)normalized-evaluator-cl-set5857,270425
(defun chk-evaluator (evfn wrld ctx state)chk-evaluator5867,270749
(defun defevaluator-form/defthms (evfn prefix i clauses)defevaluator-form/defthms5948,274763
(defun defevaluator-form/fns-clauses (evfn fn-args-lst)defevaluator-form/fns-clauses5963,275503
(defconst *defevaluator-form-base-theory**defevaluator-form-base-theory*5985,276273
(defun defevaluator-form (evfn evfn-lst fn-args-lst)defevaluator-form5994,276616
(defun pairs-to-macro-alias-msgs (alist)pairs-to-macro-alias-msgs6046,278681
(defun defevaluator-check-msg (alist macro-aliases wrld bad macro-alist)defevaluator-check-msg6053,278971
(defun defevaluator-check (x evfn evfn-lst fn-args-lst ctx state)defevaluator-check6089,280813
(defun defevaluator-check-form (x evfn evfn-lst fn-args-lst)defevaluator-check-form6115,281949
(defmacro defevaluator (&whole x evfn evfn-lst fn-args-lst &key skip-checks)defevaluator6129,282308
(deflabel term-tableterm-table6251,287343
(defun remove-meta-extract-contextual-hyps (hyps ev mfc-symbol a)remove-meta-extract-contextual-hyps6287,288716
(defun remove-meta-extract-global-hyps (hyps ev)remove-meta-extract-global-hyps6318,290111
(defun meta-rule-hypothesis-functions (hyp ev x a mfc-symbol)meta-rule-hypothesis-functions6338,290820
(defun meta-fn-args (term extendedp ens state)meta-fn-args6380,292547
(defun chk-meta-function (metafn name trigger-fns extendedpchk-meta-function6406,293397
(defun ev-lst-from-ev (ev wrld)ev-lst-from-ev6460,295804
(defun attached-fns (fns wrld)attached-fns6469,296010
(defun siblings (f wrld)siblings6480,296461
(defun canonical-sibling (f wrld)canonical-sibling6485,296620
(defun canonical-ffn-symbs (term wrld ans ignore-fns rlp)canonical-ffn-symbs6494,296921
(defun canonical-ffn-symbs-lst (lst wrld ans ignore-fns rlp)canonical-ffn-symbs-lst6521,297849
(defun collect-canonical-siblings (fns wrld ans ignore-fns)collect-canonical-siblings6532,298125
(defun immediate-canonical-ancestors (fn wrld ignore-fns rlp)immediate-canonical-ancestors6544,298537
(defun canonical-ancestors-rec (fns wrld ans rlp)canonical-ancestors-rec6571,299948
(defun canonical-ancestors (fn wrld rlp)canonical-ancestors6586,300493
(defun canonical-ancestors-lst (fns wrld)canonical-ancestors-lst6599,301030
(defun chk-evaluator-use-in-rule (name meta-fn hyp-fn extra-fns rule-type evchk-evaluator-use-in-rule6607,301296
(defun chk-rule-fn-guard (function-string rule-type fn ctx wrld state)chk-rule-fn-guard6759,308748
(defun chk-acceptable-meta-rule (name trigger-fns term ctx ens wrld state)chk-acceptable-meta-rule6803,310822
(defun add-meta-rule1 (lst rule wrld)add-meta-rule16917,316267
(defun maybe-putprop-lst (symb-lst key val wrld)maybe-putprop-lst6931,316813
(defun mark-attachment-disallowed2 (fns msg wrld)mark-attachment-disallowed26941,317166
(defun mark-attachment-disallowed1 (canonical-fns msg wrld)mark-attachment-disallowed16967,318311
(defun mark-attachment-disallowed (meta-fns ev msg wrld)mark-attachment-disallowed6976,318669
(defun add-meta-rule (rune nume trigger-fns term backchain-limit wrld)add-meta-rule6989,319176
(deflabel elimelim7044,321275
(defun destructors (term ans)destructors7187,328334
(defun destructors-lst (lst ans)destructors-lst7203,328968
(defun strip-ffn-symbs (lst)strip-ffn-symbs7210,329128
(defun chk-acceptable-elim-rule1 (name vars dests ctx wrld state)chk-acceptable-elim-rule17215,329270
(defun chk-acceptable-elim-rule (name term ctx wrld state)chk-acceptable-elim-rule7238,330281
(defun add-elim-rule1 (rune nume hyps equiv lhs rhs lst dests wrld)add-elim-rule17293,332599
(defun add-elim-rule (rune nume term wrld)add-elim-rule7318,333707
(deflabel generalizegeneralize7330,334150
(defun chk-acceptable-generalize-rule (name term ctx wrld state)chk-acceptable-generalize-rule7369,335647
(defun add-generalize-rule (rune nume term wrld)add-generalize-rule7376,335839
(deflabel type-prescriptiontype-prescription7388,336271
(defun find-type-prescription-pat (term ens wrld)find-type-prescription-pat7575,346019
(defun type-prescription-disjunctp (var term)type-prescription-disjunctp7617,347766
(defun type-prescription-conclp (var concl)type-prescription-conclp7663,349973
(defun subst-nil-into-type-prescription-disjunct (var term)subst-nil-into-type-prescription-disjunct7688,351071
(defun subst-nil-into-type-prescription-concl (var concl)subst-nil-into-type-prescription-concl7713,352024
(defun unprettyify-tp (term)unprettyify-tp7745,353461
(defun destructure-type-prescription (name typed-term term ens wrld)destructure-type-prescription7762,354031
(defun add-type-prescription-rule (rune nume typed-term termadd-type-prescription-rule7923,363163
(defun strong-compound-recognizer-p (fn recognizer-alist ens)strong-compound-recognizer-p8000,366460
(defun warned-non-rec-fns-for-tp (term recognizer-alist ens wrld)warned-non-rec-fns-for-tp8010,366943
(defun warned-non-rec-fns-tp-hyps1 (hyps recognizer-alist ens wrld acc)warned-non-rec-fns-tp-hyps18036,368020
(defun warned-non-rec-fns-tp-hyps (hyps ens wrld)warned-non-rec-fns-tp-hyps8053,368857
(defun chk-acceptable-type-prescription-rule (name typed-term termchk-acceptable-type-prescription-rule8058,369057
(deflabel equivalenceequivalence8195,376333
(defun boolean-fn (fn)boolean-fn8498,386253
(defun reflexivity (fn)reflexivity8506,386451
(defun symmetry (fn)symmetry8512,386541
(defun transitivity (fn)transitivity8519,386655
(defun equivalence-relation-condition (fn)equivalence-relation-condition8527,386806
(defun find-candidate-equivalence-relation (clauses)find-candidate-equivalence-relation8545,387566
(defun collect-problematic-pre-equivalence-rule-names (lst)collect-problematic-pre-equivalence-rule-names8559,388081
(defun chk-acceptable-equivalence-rule (name term ctx wrld state)chk-acceptable-equivalence-rule8578,389127
(defun add-equivalence-rule (rune nume term ens wrld)add-equivalence-rule8701,395263
(deflabel refinementrefinement8841,401371
(defun chk-acceptable-refinement-rule (name term ctx wrld state)chk-acceptable-refinement-rule8898,403559
(defun collect-coarsenings (wrld)collect-coarsenings8937,405494
(defun putprop-coarsenings (alist wrld)putprop-coarsenings8947,405823
(defun union-values (lst alist)union-values8975,407124
(defun extend-value-set (lst alist)extend-value-set8983,407363
(defun extend-each-value-set (alist1 alist2)extend-each-value-set8997,408028
(defun close-value-sets (alist)close-value-sets9007,408359
(defun add-refinement-rule (name nume term wrld)add-refinement-rule9021,408987
(deflabel congruencecongruence9042,409781
(defun corresponding-args-eq-except (args1 args2 xk yk)corresponding-args-eq-except9191,416688
(defun interpret-term-as-congruence-rule (name term wrld)interpret-term-as-congruence-rule9205,417281
(defun some-congruence-rule-same (equiv rules)some-congruence-rule-same9286,421209
(defun some-congruence-rule-has-refinement (equiv rules wrld)some-congruence-rule-has-refinement9295,421505
(defun chk-acceptable-congruence-rule (name term ctx wrld state)chk-acceptable-congruence-rule9305,421863
(defun putnth (val n lst)putnth9383,425609
(defun add-congruence-rule-to-congruence (rule k congruence)add-congruence-rule-to-congruence9390,425871
(defun add-congruence-rule (rune nume term wrld)add-congruence-rule9400,426278
(deflabel definitiondefinition9446,428466
(defun chk-destructure-definition (name term ctx wrld state)chk-destructure-definition9619,438333
(defun chk-acceptable-definition-install-body (fn hyps equiv args bodychk-acceptable-definition-install-body9631,438896
(defun chk-acceptable-definition-rulechk-acceptable-definition-rule9702,441843
(deflabel inductioninduction9752,443989
(defun chk-acceptable-induction-rule (name term ctx wrld state)chk-acceptable-induction-rule9915,452723
(defun add-induction-rule (rune nume pat-term cond-term scheme-term term wrld)add-induction-rule9922,452914
(deflabel type-set-invertertype-set-inverter9939,453584
(defun chk-acceptable-type-set-inverter-rule (name ts term ctx ens wrld state)chk-acceptable-type-set-inverter-rule9998,456157
(defun add-type-set-inverter-rule (rune nume ts term ens wrld)add-type-set-inverter-rule10066,459047
(deflabel clause-processorclause-processor10095,460169
(defun tilde-@-illegal-clause-processor-sig-msg (cl-proc stobjs-in stobjs-out)tilde-@-illegal-clause-processor-sig-msg10387,474159
(defun destructure-clause-processor-rule (term)destructure-clause-processor-rule10422,475370
(defun chk-acceptable-clause-processor-rule (name term ctx wrld state)chk-acceptable-clause-processor-rule10447,476369
(defun add-clause-processor-rule (name term wrld)add-clause-processor-rule10555,481989
(defun trusted-clause-processor-table-guard (key val wrld)trusted-clause-processor-table-guard10600,483847
(defmacro define-trusted-clause-processordefine-trusted-clause-processor10681,487696
(defun primitive-instructionp (instr state)primitive-instructionp11111,507258
(defun non-primitive-instructions (instructions state)non-primitive-instructions11119,507571
(defun chk-primitive-instruction-listp (instructions ctx state)chk-primitive-instruction-listp11129,507884
(defun translate-instructions (name instructions ctx wrld state)translate-instructions11137,508123
(defun controller-alistp (clique alist wrld)controller-alistp11144,508371
(defun alist-to-keyword-alist (alist ans)alist-to-keyword-alist11164,509108
(defun loop-stopper-alist-p (x wrld)loop-stopper-alist-p11176,509546
(defun guess-controller-alist-for-definition-rule (names formals body ctx wrldguess-controller-alist-for-definition-rule11189,509900
(defun chk-legal-linear-trigger-terms1 (term lst name ctx state)chk-legal-linear-trigger-terms111204,510623
(defun chk-legal-linear-trigger-terms (terms lst name ctx state)chk-legal-linear-trigger-terms11225,511653
(defun backchain-limit-listp (lst)backchain-limit-listp11253,513067
(defun eliminate-macro-aliases (lst macro-aliases wrld)eliminate-macro-aliases11266,513377
(defun translate-rule-class-alist (token alist seen corollary name x ctx enstranslate-rule-class-alist11293,514749
(defun translate-rule-class1 (class tflg name x ctx ens wrld state)translate-rule-class112006,553091
(defun reason-for-non-keyword-value-listp (x)reason-for-non-keyword-value-listp12067,555824
(defun translate-rule-class (name x thm ctx ens wrld state)translate-rule-class12086,556388
(defun translate-rule-classes1 (name classes thm ctx ens wrld state)translate-rule-classes112137,558695
(defun translate-rule-classes (name classes thm ctx ens wrld state)translate-rule-classes12159,559553
(defun chk-acceptable-x-rule (name class ctx ens wrld state)chk-acceptable-x-rule12190,561022
(defun chk-acceptable-x-rules (name classes ctx ens wrld state)chk-acceptable-x-rules12275,564814
(defun collect-keys-eq (sym-list alist)collect-keys-eq12290,565517
(defun chk-acceptable-rules (name classes ctx ens wrld state)chk-acceptable-rules12299,565873
(defun add-x-rule (rune nume class ens wrld state)add-x-rule12389,569095
(defun add-rules1 (mapping-pairs classes ens wrld state)add-rules112500,574125
(defun truncate-class-alist (alist term)truncate-class-alist12519,574965
(defun truncate-classes (classes term)truncate-classes12537,575756
(defun make-runes1 (event-name classes runes)make-runes112555,576635
(defun make-runes (event-name classes)make-runes12594,578280
(defun make-runic-mapping-pairs (nume runes)make-runic-mapping-pairs12602,578518
(defun add-rules (name classes term untranslated-term ens wrld state)add-rules12616,579057
(defun redundant-theoremp (name term classes wrld)redundant-theoremp12639,580265
(defun non-tautological-classes (term classes)non-tautological-classes12652,580843
(defun prove-corollaries1 (name term i n rule-classes ens wrld ctx state ttree)prove-corollaries112670,581640
(defun prove-corollaries (name term rule-classes ens wrld ctx state)prove-corollaries12730,584671
(defun enabled-runep-string (rune ens wrld)enabled-runep-string12764,586094
(defun untranslate-hyps (hyps wrld)untranslate-hyps12769,586208
(defun info-for-lemmas (lemmas numes ens wrld)info-for-lemmas12774,586385
(defun world-to-next-event (wrld)world-to-next-event12811,588368
(defun assoc-eq-eq (x y alist)assoc-eq-eq12819,588619
(defun actual-props (props seen acc)actual-props12830,588955
(defun info-for-well-founded-relation-rules (rules)info-for-well-founded-relation-rules12848,589577
(defun info-for-built-in-clause-rules1 (rules numes ens wrld)info-for-built-in-clause-rules112863,590175
(defun info-for-built-in-clause-rules (alist numes ens wrld)info-for-built-in-clause-rules12880,590964
(defun info-for-compound-recognizer-rules (rules numes ens wrld)info-for-compound-recognizer-rules12886,591204
(defun info-for-generalize-rules (rules numes ens wrld)info-for-generalize-rules12910,592386
(defun info-for-linear-lemmas (rules numes ens wrld)info-for-linear-lemmas12927,593149
(defun info-for-eliminate-destructors-rule (rule numes ens wrld)info-for-eliminate-destructors-rule12957,594782
(defun info-for-congruences (val numes ens wrld)info-for-congruences12985,596259
(defun info-for-coarsenings (val numes ens wrld)info-for-coarsenings12993,596468
(defun info-for-forward-chaining-rules (rules numes ens wrld)info-for-forward-chaining-rules13001,596661
(defun decode-type-set-lst (lst)decode-type-set-lst13029,598039
(defun info-for-type-prescriptions (rules numes ens wrld)info-for-type-prescriptions13035,598178
(defun info-for-induction-rules (rules numes ens wrld)info-for-induction-rules13065,599748
(defun info-for-type-set-inverter-rules (rules numes ens wrld)info-for-type-set-inverter-rules13088,600857
(defun info-for-x-rules (sym key val numes ens wrld)info-for-x-rules13108,601800
(defun info-for-rules (props numes ens wrld)info-for-rules13167,603913
(defun print-info-for-rules-entry (keys vals chan state)print-info-for-rules-entry13177,604304
(defun print-info-for-rules (info chan state)print-info-for-rules13202,605499
(defun pr-body (wrld-segment numes wrld state)pr-body13212,605879
(defun pr-fn (name state)pr-fn13221,606121
(defun print-clause-processor-rules1 (alist wrld state)print-clause-processor-rules113235,606786
(defmacro print-clause-processor-rules ()print-clause-processor-rules13248,607309
(defun new-numes (world-segment)new-numes13254,607543
(defun world-to-next-command (wrld ans)world-to-next-command13265,607896
(defun pr!-fn (cd state)pr!-fn13272,608164
(defmacro pr (name)pr13281,608455
(defmacro pr! (cd)pr!13328,610048
(defun disabledp-fn-lst (runic-mapping-pairs ens)disabledp-fn-lst13355,610978
(defun disabledp-fn (name ens wrld)disabledp-fn13362,611299
(defmacro disabledp (name)disabledp13385,612295
(defun access-x-rule-rune (x rule)access-x-rule-rune13415,613529
(defun collect-x-rules-of-rune (x rune lst ans)collect-x-rules-of-rune13459,615785
(defun collect-congruence-rules-of-rune-in-geneqv-lst (geneqv-lst rune ans)collect-congruence-rules-of-rune-in-geneqv-lst13470,616190
(defun collect-congruence-rules-of-rune (congruences rune ans)collect-congruence-rules-of-rune13482,616639
(defun find-rules-of-rune2 (rune sym key val ans)find-rules-of-rune213497,617285
(defun find-rules-of-rune1 (rune props ans)find-rules-of-rune113591,621367
(defun find-rules-of-rune (rune wrld)find-rules-of-rune13607,622118
(defun collect-non-backchain-subclass (rules)collect-non-backchain-subclass13651,624128
(defun chk-acceptable-monitor (rune expr ctx state)chk-acceptable-monitor13661,624504
(defun chk-acceptable-monitors (lst ctx state)chk-acceptable-monitors13736,628130
(defun monitor1 (rune form ctx state)monitor113757,628983
(defun unmonitor1 (rune ctx state)unmonitor113776,629749
(defun monitor-fn (rune expr state)monitor-fn13795,630536
(defun unmonitor-fn (rune ctx state)unmonitor-fn13821,631360
(defun monitored-runes-fn (state)monitored-runes-fn13864,632935
(defun brr-fn (flg state)brr-fn13880,633394
(defmacro brr (flg)brr13895,633823
(deflabel why-brrwhy-brr13967,637789
(defmacro brr@ (sym)brr@14024,640860
(defmacro monitor (rune expr)monitor14151,647625
(defmacro unmonitor (rune)unmonitor14321,656705
(defmacro monitored-runes ()monitored-runes14348,657580
(defun proceed-from-brkpt1 (action runes ctx state)proceed-from-brkpt114364,657965
(defun exit-brr (state)exit-brr14396,659232
(defun ok-if-fn (term state)ok-if-fn14407,659603
(defmacro ok-if (term)ok-if14415,659848
(defun print-rule-storage-dependencies (name ttree state)print-rule-storage-dependencies14462,661893
(defun defaxiom-supporters (tterm name ctx wrld state)defaxiom-supporters14479,662505
(defun defaxiom-fn (name term state rule-classes doc event-form)defaxiom-fn14532,665346
(defun warn-on-inappropriate-defun-mode (assumep event-form ctx state)warn-on-inappropriate-defun-mode14625,669733
(defun add-hyp-standardp-var-lst (vars)add-hyp-standardp-var-lst14639,670253
(defun strengthen-hyps-using-transfer-principle (hyps vars)strengthen-hyps-using-transfer-principle14646,670441
(defun weaken-using-transfer-principle (term)weaken-using-transfer-principle14658,670781
(defun remove-standardp-hyp (tterm)remove-standardp-hyp14682,671651
(defun remove-standardp-hyps (tterm)remove-standardp-hyps14690,671886
(defun remove-standardp-hyps-and-standardp-conclusion (tterm)remove-standardp-hyps-and-standardp-conclusion14702,672289
(defun chk-classical-term-or-standardp-of-classical-term (tterm term ctx wrld state)chk-classical-term-or-standardp-of-classical-term14713,672646
(defmacro with-waterfall-parallelism-timings (name form)with-waterfall-parallelism-timings14731,673403
(defmacro with-waterfall-parallelism-timings (name form)with-waterfall-parallelism-timings14741,673811
(defun defthm-fn1 (name term statedefthm-fn114745,673903
(defun defthm-fn (name term statedefthm-fn14891,680973
(defmacro thm (term &key hints otf-flg doc)thm14914,681575
(defun thm-fn (term state hints otf-flg doc)thm-fn14946,682400
(defun chk-extensible-rule-classes (rule-classes ctx state)chk-extensible-rule-classes14979,683829
(defun extend-rule-classes (class rule-classes)extend-rule-classes14988,684177
(defun gen-new-name-in-package-of-symbol1 (char-lst cnt pkgsym wrld)gen-new-name-in-package-of-symbol114999,684537
(defun gen-new-name-in-package-of-symbol (sym pkgsym wrld)gen-new-name-in-package-of-symbol15019,685333
(defmacro defequiv (equivdefequiv15039,686055
(defmacro defrefinement (equiv1 equiv2defrefinement15098,688147
(defmacro defcong (&whole xdefcong15153,690082

other-events.lisp,60906
(defun legal-initp (x)legal-initp46,2129
(defun macro-arglist-keysp (args keys-passed)macro-arglist-keysp58,2576
(defun macro-arglist-after-restp (args)macro-arglist-after-restp91,4156
(defun macro-arglist-optionalp (args)macro-arglist-optionalp98,4362
(defun macro-arglist1p (args)macro-arglist1p125,5340
(defun subsequencep (lst1 lst2)subsequencep142,5953
(defun collect-lambda-keywordps (lst)collect-lambda-keywordps155,6395
(defun macro-args-structurep (args)macro-args-structurep162,6655
(defun macro-vars-key (args)macro-vars-key182,7611
(defun macro-vars-after-rest (args)macro-vars-after-rest206,8490
(defun macro-vars-optional (args)macro-vars-optional219,8841
(defun macro-vars (args)macro-vars240,9591
(defun chk-legal-defconst-name (name state)chk-legal-defconst-name260,10312
(defun defconst-fn1 (name val doc doc-pair w state)defconst-fn1274,10944
(defvar *hcomp-fn-ht* nil)*hcomp-fn-ht*285,11207
(defvar *hcomp-const-ht* nil)*hcomp-const-ht*286,11234
(defvar *hcomp-macro-ht* nil)*hcomp-macro-ht*287,11264
(defvar *hcomp-fn-alist* nil)*hcomp-fn-alist*288,11294
(defvar *hcomp-const-alist* nil)*hcomp-const-alist*289,11324
(defvar *hcomp-macro-alist* nil)*hcomp-macro-alist*290,11357
(defconstant *hcomp-fake-value* 'acl2_invisible::hcomp-fake-value)*hcomp-fake-value*291,11390
(defvar *hcomp-book-ht* nil)*hcomp-book-ht*292,11457
(defvar *hcomp-const-restore-ht* nil)*hcomp-const-restore-ht*293,11486
(defvar *hcomp-fn-macro-restore-ht**hcomp-fn-macro-restore-ht*294,11524
(defvar *declaim-list* nil)*declaim-list*327,12707
(defrec hcomp-book-ht-entryhcomp-book-ht-entry331,12739
(defun defconst-val-raw (full-book-name name)defconst-val-raw341,13031
(defun defconst-val (name form ctx wrld state)defconst-val352,13520
(defun defconst-fn (name form state doc event-form)defconst-fn437,16794
(defun chk-legal-init-msg (x)chk-legal-init-msg495,19265
(defun chk-legal-init (x ctx state)chk-legal-init520,20228
(defun chk-macro-arglist-keys (args keys-passed)chk-macro-arglist-keys525,20372
(defun chk-macro-arglist-after-rest (args)chk-macro-arglist-after-rest598,24489
(defun chk-macro-arglist-optional (args)chk-macro-arglist-optional605,24749
(defun chk-macro-arglist1 (args)chk-macro-arglist1640,26388
(defun chk-macro-arglist-msg (args chk-state wrld)chk-macro-arglist-msg660,27229
(defun chk-macro-arglist (args chk-state ctx state)chk-macro-arglist740,31252
(defun defmacro-fn1 (name args doc doc-pair guard body w state)defmacro-fn1745,31438
(defun chk-defmacro-width (rst)chk-defmacro-width761,31975
(defun redundant-defmacrop (name args guard body w)redundant-defmacrop775,32477
(defun defmacro-fn (mdef state event-form)defmacro-fn793,33303
(defconst *initial-event-defmacros**initial-event-defmacros*924,40005
(defun boot-translate (x)boot-translate1145,47975
(defun primordial-event-macro-and-fn1 (actuals)primordial-event-macro-and-fn11188,49682
(defun primordial-event-macro-and-fn (form wrld)primordial-event-macro-and-fn1217,51099
(defun primordial-event-macros-and-fns (lst wrld)primordial-event-macros-and-fns1352,57759
(defconst *initial-type-prescriptions**initial-type-prescriptions*1368,58354
(defun collect-world-globals (wrld ans)collect-world-globals1390,59173
(defun primordial-world-globals (operating-system)primordial-world-globals1397,59443
(defun arglists-to-nils (arglists)arglists-to-nils1543,66398
(defconst *unattachable-primitives**unattachable-primitives*1549,66626
(defun primordial-world (operating-system)primordial-world1567,67349
(defun same-name-twice (l)same-name-twice1633,69780
(defun conflicting-imports (l)conflicting-imports1641,70012
(defun chk-new-stringp-name (ev-type name ctx w state)chk-new-stringp-name1648,70183
(deflabel package-reincarnation-import-restrictionspackage-reincarnation-import-restrictions1687,71730
(defun chk-package-reincarnation-import-restrictions (name proposed-imports)chk-package-reincarnation-import-restrictions1750,75086
(defun convert-book-name-to-cert-name (x cert-op)convert-book-name-to-cert-name1762,75524
(defun unrelativize-book-path (lst dir)unrelativize-book-path1785,76415
(defun tilde-@-defpkg-error-phrase (name package-entry new-not-old old-not-newtilde-@-defpkg-error-phrase1794,76791
(defconst *1*-pkg-prefix**1*-pkg-prefix*1843,79466
(defun chk-acceptable-defpkg (name form defpkg-book-path hidden-p ctx w state)chk-acceptable-defpkg1856,79892
(defun defpkg-fn (name form state doc book-path hidden-p event-form)defpkg-fn2051,88562
(defun theory-fn-callp (x)theory-fn-callp2227,97485
(defun intersection-augmented-theories-fn1 (lst1 lst2 ans)intersection-augmented-theories-fn12250,98346
(defmacro check-theory (lst wrld ctx form)check-theory2270,99314
(defun intersection-theories-fn (lst1 lst2 wrld)intersection-theories-fn2278,99624
(defmacro intersection-theories (lst1 lst2)intersection-theories2287,99971
(defun union-augmented-theories-fn1 (lst1 lst2 ans)union-augmented-theories-fn12319,100954
(defun union-theories-fn1 (lst1 lst2 nume wrld ans)union-theories-fn12336,101806
(defun union-theories-fn (lst1 lst2 lst1-known-to-be-runic wrld)union-theories-fn2360,102903
(defmacro union-theories (lst1 lst2)union-theories2399,104363
(defun set-difference-augmented-theories-fn1 (lst1 lst2 ans)set-difference-augmented-theories-fn12445,105656
(defun set-difference-theories-fn1 (lst1 lst2 nume wrld ans)set-difference-theories-fn12460,106379
(defun set-difference-theories-fn (lst1 lst2 lst1-known-to-be-runic wrld)set-difference-theories-fn2484,107459
(defmacro set-difference-theories (lst1 lst2)set-difference-theories2515,108651
(defun universal-theory-fn1 (lst ans redefined)universal-theory-fn12554,109949
(defun universal-theory-fn (logical-name wrld)universal-theory-fn2606,112806
(defmacro universal-theory (logical-name)universal-theory2637,114355
(defun function-theory-fn1 (token lst ans redefined)function-theory-fn12687,116403
(defun function-theory-fn (logical-name wrld)function-theory-fn2747,119313
(defmacro function-theory (logical-name)function-theory2763,119971
(defun executable-counterpart-theory-fn (logical-name wrld)executable-counterpart-theory-fn2802,121292
(defmacro executable-counterpart-theory (logical-name)executable-counterpart-theory2817,121929
(defun standard-theories (wrld)standard-theories2860,123480
(defun current-theory-fn (logical-name wrld)current-theory-fn2866,123730
(defmacro current-theory (logical-name)current-theory2886,124527
(defconst *initial-return-last-table**initial-return-last-table*3020,129526
(defun end-prehistoric-world (wrld)end-prehistoric-world3048,130830
(defun theory-namep (name wrld)theory-namep3092,132881
(defun theory-fn (name wrld)theory-fn3101,133138
(defmacro theory (name)theory3113,133547
(defun deftheory-fn (name expr state doc event-form)deftheory-fn3143,134400
(defun in-theory-fn (expr state doc event-form)in-theory-fn3265,139761
(defun in-arithmetic-theory-fn (expr state doc event-form)in-arithmetic-theory-fn3331,142480
(defmacro disable (&rest rst)disable3394,145110
(defmacro enable (&rest rst)enable3434,146442
(defmacro theory-invariant (&whole event-form term &key key (error 't))theory-invariant3488,148342
(defmacro theory-invariant (&rest args)theory-invariant3689,158323
(defmacro incompatible (rune1 rune2)incompatible3693,158397
(deflabel signaturesignature3734,159871
(defconst *generic-bad-signature-string**generic-bad-signature-string*3883,167472
(defconst *signature-keywords**signature-keywords*3889,167759
(defun duplicate-key-in-keyword-value-listp (l)duplicate-key-in-keyword-value-listp3894,167866
(defun chk-signature (x ctx wrld state)chk-signature3901,168111
(defun chk-signatures (signatures ctx wrld state)chk-signatures4167,180958
(defun chk-acceptable-encapsulate1 (signatures form-lst ctx wrld state)chk-acceptable-encapsulate14219,183573
(defun primitive-event-macros ()primitive-event-macros4270,186152
(deflabel embedded-event-formembedded-event-form4410,190850
(defun name-introduced (trip functionp)name-introduced4565,197154
(defun chk-embedded-event-form-orig-form-msg (orig-form state)chk-embedded-event-form-orig-form-msg4642,200634
(defun chk-embedded-event-form (form orig-form wrld ctx state names portcullispchk-embedded-event-form4649,200883
(defun destructure-expansion (form)destructure-expansion5006,218724
(defun rebuild-expansion (wrappers form)rebuild-expansion5020,219290
(defun set-raw-mode-on (state)set-raw-mode-on5025,219467
(defun set-raw-mode-off (state)set-raw-mode-off5030,219634
(defmacro set-raw-mode-on! ()set-raw-mode-on!5036,219821
(defmacro set-raw-mode (flg)set-raw-mode5054,220469
(defun-one-output stobj-out (val)stobj-out5193,227030
(defun mv-ref! (i)mv-ref!5204,227422
(defmacro add-raw-arity (name val)add-raw-arity5243,228250
(defmacro remove-raw-arity (name)remove-raw-arity5296,230266
(defun raw-arity (form wrld state)raw-arity5320,231097
(defun alist-to-bindings (alist)alist-to-bindings5383,233809
(defun-one-output acl2-raw-eval-form-to-eval (form)acl2-raw-eval-form-to-eval5390,233991
(defun acl2-raw-eval (form state)acl2-raw-eval5420,235214
(defun acl2-raw-eval (form state)acl2-raw-eval5443,236099
(defun acl2-raw-eval (form state)acl2-raw-eval5461,236795
(defun get-and-chk-last-make-event-expansion (form wrld ctx state names)get-and-chk-last-make-event-expansion5464,236870
(defconst *local-value-triple-elided**local-value-triple-elided*5491,238053
(defun elide-locals-rec (form strongp)elide-locals-rec5501,238311
(defun elide-locals-lst (x strongp)elide-locals-lst5556,240902
(defun elide-locals (form environment strongp)elide-locals5567,241343
(defun make-record-expansion (event expansion)make-record-expansion5591,242508
(defun eval-event-lst (index expansion-alist ev-lst quietp environmenteval-event-lst5598,242731
(defun equal-insig (insig1 insig2)equal-insig5803,253064
(defun bad-signature-alist (insigs kwd-value-list-lst udf-fns wrld)bad-signature-alist5823,253981
(defmacro if-ns (test tbr fbr ctx)if-ns5888,257110
(defun tilde-*-bad-insigs-phrase1 (alist)tilde-*-bad-insigs-phrase15907,257634
(defun tilde-*-bad-insigs-phrase (alist)tilde-*-bad-insigs-phrase5934,258933
(defun union-eq-cars (alist)union-eq-cars5946,259429
(defun chk-acceptable-encapsulate2 (insigs kwd-value-list-lst wrld ctx state)chk-acceptable-encapsulate25950,259552
(defun conjoin-into-alist (fn thm alist)conjoin-into-alist5993,261304
(defun classes-theorems (classes)classes-theorems6007,261833
(defun constraints-introduced1 (thms fns ans)constraints-introduced16019,262217
(defun new-trips (wrld3 proto-wrld3 seen acc)new-trips6035,262844
(defun constraints-introduced (new-trips fns ans)constraints-introduced6115,267165
(defun putprop-constraints (fn constrained-fns constraint-lstputprop-constraints6235,272394
(deflabel local-incompatibilitylocal-incompatibility6269,273894
(defun maybe-install-acl2-defaults-table (acl2-defaults-table state)maybe-install-acl2-defaults-table6371,279021
(defun in-encapsulatep (embedded-event-lst non-trivp)in-encapsulatep6389,279713
(defun update-for-redo-flat (n ev-lst state)update-for-redo-flat6405,280274
(defmacro redo-flat (&key (succ-ld-skip-proofsp 't)redo-flat6424,281017
(defun cert-op (state)cert-op6574,288107
(defun eval-event-lst-environment (in-encapsulatep state)eval-event-lst-environment6592,288839
(defun process-embedded-eventsprocess-embedded-events6611,289576
(defun constrained-functions (exported-fns sig-fns new-trips)constrained-functions6901,305036
(defun collect-logicals (names wrld)collect-logicals6927,306283
(defun exported-function-names (new-trips)exported-function-names6936,306567
(defun get-subversives (fns wrld)get-subversives6948,306985
(defun ancestral-ffn-symbs-lst (lst trips ans)ancestral-ffn-symbs-lst6958,307410
(defun constraints-list (fns wrld acc seen)constraints-list6962,307565
(defun encapsulate-constraint (sig-fns exported-names new-trips wrld)encapsulate-constraint6977,308277
(defun new-dependent-clause-processors (new-tbl old-tbl)new-dependent-clause-processors7087,313499
(defun bogus-exported-compliants (names exports-with-sig-ancestors sig-fnsbogus-exported-compliants7104,314206
(defun encapsulate-pass-2 (insigs kwd-value-list-lst ev-lstencapsulate-pass-27157,316789
(defun tilde-@-abbreviate-object-phrase (x)tilde-@-abbreviate-object-phrase7948,347075
(defun encapsulate-ctx (signatures form-lst)encapsulate-ctx7982,348132
(defun print-encapsulate-msg1 (insigs form-lst state)print-encapsulate-msg18008,349199
(defun print-encapsulate-msg2 (insigs form-lst state)print-encapsulate-msg28025,349905
(defun print-encapsulate-msg3/exported-names (insigs lst)print-encapsulate-msg3/exported-names8037,350239
(defun print-encapsulate-msg3/constraints (constrained-fns constraintsprint-encapsulate-msg3/constraints8056,350843
(defun print-encapsulate-msg3 (ctx insigs form-lst exported-namesprint-encapsulate-msg38104,352831
(defun find-first-non-local-name (x)find-first-non-local-name8181,356861
(defun find-first-non-local-name-lst (lst)find-first-non-local-name-lst8252,359697
(defun corresponding-encap-events (old-evs new-evs ans)corresponding-encap-events8271,360526
(defun corresponding-encaps (old new)corresponding-encaps8298,361632
(defun redundant-encapsulate-tuplep (event-form mode ruler-extenders vgeredundant-encapsulate-tuplep8306,361876
(defun redundant-encapsulatep (signatures ev-lst event-form wrld)redundant-encapsulatep8345,363883
(defun mark-missing-as-hidden-p (a1 a2)mark-missing-as-hidden-p8427,367945
(defun known-package-alist-included-p (a1 a2)known-package-alist-included-p8440,368470
(defun encapsulate-fix-known-package-alist (pass1-k-p-alist wrld)encapsulate-fix-known-package-alist8453,369024
(defun subst-by-position1 (alist lst index acc)subst-by-position18488,370979
(defun subst-by-position (alist lst index)subst-by-position8508,371696
(defun intro-udf-guards (insigs kwd-value-list-lst wrld-acc wrld ctx state)intro-udf-guards8526,372515
(defun intro-udf-non-classicalp (insigs kwd-value-list-lst wrld)intro-udf-non-classicalp8567,374321
(defun assoc-proof-supporters-alist (sym alist)assoc-proof-supporters-alist8582,375100
(defun update-proof-supporters-alist-3 (names local-alist old new wrld)update-proof-supporters-alist-38590,375392
(defun posn-first-non-event (names wrld idx)posn-first-non-event8617,376592
(defun update-proof-supporters-alist-2 (names local-alist wrld)update-proof-supporters-alist-28624,376843
(defun update-proof-supporters-alist-1 (namex names local-alistupdate-proof-supporters-alist-18635,377342
(defun update-proof-supporters-alist (new-proof-supporters-alistupdate-proof-supporters-alist8653,378225
(defun install-proof-supporters-alist (new-proof-supporters-alistinstall-proof-supporters-alist8674,379117
(defun encapsulate-fn (signatures ev-lst state event-form)encapsulate-fn8687,379710
(defun progn-fn1 (ev-lst progn!p bindings state)progn-fn19048,398943
(defun progn-fn (ev-lst state)progn-fn9137,403018
(defun progn!-fn (ev-lst bindings state)progn!-fn9140,403086
(defun make-event-ctx (event-form)make-event-ctx9146,403403
(defun protected-eval (form on-behalf-of ctx state aok)protected-eval9151,403571
(defun make-event-debug-pre (form on-behalf-of state)make-event-debug-pre9211,406334
(defun make-event-debug-post (debug-depth expansion0 state)make-event-debug-post9228,407057
(defmacro do-proofs? (do-proofsp form)do-proofs?9237,407419
(defun make-event-fn2 (expansion0 whole-form in-encapsulatep check-expansionmake-event-fn29254,407934
(defun make-event-fn2-lst (expansion-lst whole-form in-encapsulatepmake-event-fn2-lst9301,409633
(defun make-event-fn1 (expansion0 whole-form in-encapsulatep check-expansionmake-event-fn19326,410739
(defun ultimate-expansion (x)ultimate-expansion9337,411259
(defun make-event-fn (form expansion? check-expansion on-behalf-of whole-formmake-event-fn9366,412668
(deflabel booksbooks9719,430647
(deflabel community-bookscommunity-books9786,434029
(defun chk-book-name (book-name full-book-name ctx state)chk-book-name9804,434732
(defun include-book-alist-subsetp (alist1 alist2)include-book-alist-subsetp9849,436782
(defun get-portcullis-cmds (wrld cmds cbds names ctx state)get-portcullis-cmds9889,438735
(defun remove-after-last-directory-separator (p)remove-after-last-directory-separator9922,440141
(defun merge-using-dot-dot (p s)merge-using-dot-dot9930,440465
(defun our-merge-pathnames (p s)our-merge-pathnames9964,441772
(defun expand-tilde-to-user-home-dir (str os ctx state)expand-tilde-to-user-home-dir9995,442921
(defvar *canonical-unix-pathname-action**canonical-unix-pathname-action*10032,444420
(defun canonical-unix-pathname (x dir-p state)canonical-unix-pathname10044,444951
(defun unix-truename-pathname (x dir-p state)unix-truename-pathname10130,449923
(defun chk-live-state-p (fn state)chk-live-state-p10150,450738
(defun-overrides canonical-pathname (pathname dir-p state)canonical-pathname10162,451169
(defun acl2-magic-canonical-pathname (x)acl2-magic-canonical-pathname10169,451398
(defdoc canonical-pathnamecanonical-pathname10200,452401
(defun canonical-dirname! (pathname ctx state)canonical-dirname!10239,454291
(defun directory-of-absolute-pathname (pathname)directory-of-absolute-pathname10250,454717
(defun extend-pathname (dir file-name state)extend-pathname10256,454927
(defun maybe-add-separator (str)maybe-add-separator10300,456948
(defun set-cbd-fn (str state)set-cbd-fn10306,457148
(defmacro set-cbd (str)set-cbd10344,458702
(defun set-cbd-state (str state)set-cbd-state10375,459761
(defun parse-book-name (dir x extension ctx state)parse-book-name10391,460260
(defun cbd-fn (state)cbd-fn10446,462641
(defmacro cbd nilcbd10453,462948
(defun make-include-books-absolute (form cbd dir names make-event-parent os ctxmake-include-books-absolute10569,468644
(defun make-include-books-absolute-lst (forms cbd dir names make-event-parentmake-include-books-absolute-lst10777,478416
(defun first-known-package-alist (wrld-segment)first-known-package-alist10790,478944
(defmacro string-prefixp (root string)string-prefixp10810,479636
(defun relativize-book-path (filename root)relativize-book-path10819,479914
(defun relativize-book-path-lst1 (lst root)relativize-book-path-lst110844,480911
(defun relativize-book-path-lst (lst root current)relativize-book-path-lst10851,481197
(defun defpkg-items-rec (new-kpa old-kpa system-books-dirdefpkg-items-rec10859,481498
(defun defpkg-items (new-kpa ctx w state)defpkg-items10937,485286
(defun new-defpkg-list2 (imports all-defpkg-items acc seen)new-defpkg-list210950,485798
(defun make-hidden-defpkg (name imports/doc/book-path)make-hidden-defpkg10974,486633
(defun new-defpkg-list1new-defpkg-list110983,486943
(defun new-defpkg-list (defpkg-items base-kpa earlier-kpa)new-defpkg-list11017,488275
(defun term-ignore-okp (x)term-ignore-okp11060,490668
(defun term-list-ignore-okp (x)term-list-ignore-okp11071,491050
(defun hidden-defpkg-events1 (kpa system-books-dirhidden-defpkg-events111079,491201
(defun hidden-defpkg-events (kpa w ctx state)hidden-defpkg-events11135,493403
(defun fix-portcullis-cmds1 (dir cmds cbds ans names os ctx state)fix-portcullis-cmds111143,493731
(defun fix-portcullis-cmds (dir cmds cbds names os wrld ctx state)fix-portcullis-cmds11154,494238
(defun collect-uncertified-books (alist)collect-uncertified-books11206,496889
(defun chk-in-package (channel file empty-okp ctx state)chk-in-package11220,497466
(defmacro ill-formed-certificate-er (ctx mark file1 file2ill-formed-certificate-er11263,499365
(defun include-book-er-warning-summary (keyword suspect-book-action-alistinclude-book-er-warning-summary11289,500313
(defun include-book-er1 (file1 file2 msg warning-summary ctx state)include-book-er111337,502213
(defun include-book-er (file1 file2 msg keyword suspect-book-action-alist ctxinclude-book-er11352,502884
(defun post-alist-from-channel (x y ch state)post-alist-from-channel11377,504200
(defun certificate-file-and-input-channel1 (full-book-name cert-op state)certificate-file-and-input-channel111404,505372
(defmacro pcert-op-p (cert-op)pcert-op-p11412,505643
(defun certificate-file-and-input-channel (full-book-name old-cert-op state)certificate-file-and-input-channel11415,505754
(defun cert-annotations-and-checksum-from-cert-file (full-book-name state)cert-annotations-and-checksum-from-cert-file11455,507656
(defun tilde-@-cert-post-alist-phrase (full-book-name familiar-nametilde-@-cert-post-alist-phrase11475,508486
(defun tilde-*-book-check-sums-phrase1 (reqd-alist actual-alist-cddrs state)tilde-*-book-check-sums-phrase111514,510568
(defun tilde-*-book-check-sums-phrase (reqd-alist actual-alist state)tilde-*-book-check-sums-phrase11573,513273
(defun get-cmds-from-portcullis1 (eval-hidden-defpkgs ch ctx state ans)get-cmds-from-portcullis111589,514011
(defun hidden-defpkg-events-simple (kpa acc)hidden-defpkg-events-simple11620,515257
(defun get-cmds-from-portcullis (file1 file2 eval-hidden-defpkgs ch ctx state)get-cmds-from-portcullis11644,515947
(defun convert-book-name-to-port-name (x)convert-book-name-to-port-name11676,517250
(defun chk-raise-portcullis2 (file1 file2 ch port-file-p ctx state ans)chk-raise-portcullis211685,517567
(defun chk-raise-portcullis1 (file1 file2 ch port-file-p ctx state)chk-raise-portcullis111767,521726
(defun mark-local-included-books (post-alist1 post-alist2)mark-local-included-books11798,522942
(defun unmark-and-delete-local-included-books (post-alist3)unmark-and-delete-local-included-books11830,524622
(defun decimal-string-to-number (s bound expo)decimal-string-to-number11845,525344
(defun parse-version (version)parse-version11876,526727
(defun-one-output latest-release-note-string ()latest-release-note-string11921,528775
(defun earlier-acl2-versionp (version1 version2)earlier-acl2-versionp11929,529077
(defun acl2-version-r-p (version)acl2-version-r-p11958,530169
(defun ttag-alistp (x)ttag-alistp11964,530342
(defun cert-annotationsp (x)cert-annotationsp11976,530683
(defun include-book-alist-entryp (entry)include-book-alist-entryp11990,531076
(defun include-book-alistp1 (x local-markers-allowedp)include-book-alistp112002,531531
(defun include-book-alistp (x local-markers-allowedp)include-book-alistp12017,532080
(defrec cert-objcert-obj12027,532515
(defun check-sum-cert-obj (cmds pre-alist post-alist expansion-alist)check-sum-cert-obj12041,533093
(defun chk-raise-portcullis (file1 file2 ch light-chkp callerchk-raise-portcullis12052,533600
(defun chk-certificate-file1 (file1 file2 ch light-chkp callerchk-certificate-file112273,543906
(defun certificate-file (full-book-name state)certificate-file12386,549277
(defun chk-certificate-file (file1 dir caller ctx statechk-certificate-file12394,549621
(defun equal-modulo-hidden-defpkgs (cmds1 cmds2)equal-modulo-hidden-defpkgs12488,554618
(defun cert-obj-for-convert (full-book-name dir pre-alist fixed-cmdscert-obj-for-convert12506,555321
(defun symbol-name-equal (x str)symbol-name-equal12553,557980
(defun chk-acceptable-certify-book1 (file dir k cmds cert-obj cbds nameschk-acceptable-certify-book112558,558111
(defun translate-book-names (filenames cbd state acc)translate-book-names12669,563300
(defun fix-ttags (ttags ctx cbd state seen acc)fix-ttags12683,563889
(defun chk-well-formed-ttags (ttags cbd ctx state)chk-well-formed-ttags12723,565806
(defun check-certificate-file-exists (full-book-name cert-op ctx state)check-certificate-file-exists12734,566215
(defun chk-acceptable-certify-book (book-name full-book-name dirchk-acceptable-certify-book12768,567998
(defun print-objects (lst ch state)print-objects12933,576839
(defun replace-initial-substring (s old old-length new)replace-initial-substring12938,577015
(defun replace-string-prefix-in-tree (tree old old-length new)replace-string-prefix-in-tree12951,577489
(defmacro with-output-object-channel-sharing (chan filename bodywith-output-object-channel-sharing12963,578070
(defun elide-locals-and-split-expansion-alist (alist acl2x-alist x y)elide-locals-and-split-expansion-alist13000,579494
(defun make-certificate-file1 (file portcullis certification-file post-alist3make-certificate-file113046,581998
(defun make-certificate-file-relocated (file portcullis certification-filemake-certificate-file-relocated13125,585355
(defun make-certificate-file (file portcullis post-alist1 post-alist2make-certificate-file13150,586478
(defun make-certificate-files (full-book-name portcullis post-alist1make-certificate-files13295,593820
(defun open-input-object-file (file ctx state)open-input-object-file13338,595885
(defun read-object-file1 (channel state ans)read-object-file113360,596767
(defun read-object-file (file ctx state)read-object-file13372,597221
(defun chk-cert-annotationschk-cert-annotations13389,598053
(defun chk-cert-annotations-post-alistchk-cert-annotations-post-alist13457,601356
(defun chk-input-object-file (file ctx state)chk-input-object-file13544,605446
(defun include-book-dir (dir state)include-book-dir13558,606082
(defmacro include-book-dir-with-chk (soft-or-hard ctx dir)include-book-dir-with-chk13570,606643
(defun newly-defined-top-level-fns-rec (trips collect-p full-book-name acc)newly-defined-top-level-fns-rec13589,607592
(defun newly-defined-top-level-fns (old-wrld new-wrld full-book-name)newly-defined-top-level-fns13623,609206
(defun accumulate-post-alist (post-alist include-book-alist)accumulate-post-alist13654,610378
(defun skipped-proofsp-in-post-alist (post-alist)skipped-proofsp-in-post-alist13673,611248
(defun check-sum-cert (portcullis-cmds expansion-alist book-ev-lst)check-sum-cert13692,611925
(defmacro with-hcomp-bindings (do-it form)with-hcomp-bindings13705,612462
(defmacro with-hcomp-bindings (do-it form)with-hcomp-bindings13710,612558
(defmacro with-hcomp-ht-bindings (form)with-hcomp-ht-bindings13727,613172
(defmacro with-hcomp-ht-bindings (form)with-hcomp-ht-bindings13731,613238
(defun get-declaim-list (state)get-declaim-list13764,614784
(defun tilde-@-book-stack-msg (reason load-compiled-stack)tilde-@-book-stack-msg13770,614908
(defun convert-book-name-to-acl2x-name (x)convert-book-name-to-acl2x-name13802,616461
(defun acl2x-alistp (x index len)acl2x-alistp13814,616860
(defun read-acl2x-file (acl2x-file full-book-name len acl2x ctx state)read-acl2x-file13824,617128
(defun eval-port-file (full-book-name ctx state)eval-port-file13885,619738
(defun getenv! (str state)getenv!13958,623101
(defun update-pcert-books (full-book-name pcert-p wrld)update-pcert-books13967,623347
(defun convert-non-nil-symbols-to-keywords (x)convert-non-nil-symbols-to-keywords13975,623603
(defun include-book-fn1 (user-book-name stateinclude-book-fn113983,623891
(defun include-book-fn (user-book-name stateinclude-book-fn14708,660985
(defun spontaneous-decertificationp1 (ibalist alist files)spontaneous-decertificationp114810,665517
(defun spontaneous-decertificationp (alist1 alist2)spontaneous-decertificationp14856,667669
(defun remove-duplicates-equal-from-end (lst acc)remove-duplicates-equal-from-end14866,668090
(defun include-book-alist-subsetp-failure-witnesses (alist1 strip-cddrs-alist2 acc)include-book-alist-subsetp-failure-witnesses14872,668353
(defun expansion-filename (full-book-name convert-to-os-p state)expansion-filename14982,674684
(defun write-expansion-file (portcullis-cmds declaim-list new-fns-execwrite-expansion-file14999,675320
(defun collect-ideal-user-defuns1 (tl wrld ans)collect-ideal-user-defuns115174,683717
(defun collect-ideal-user-defuns (wrld)collect-ideal-user-defuns15203,684777
(defun set-difference-eq-sorted (lst1 lst2 ans)set-difference-eq-sorted15210,685016
(defun expansion-alist-pkg-names0 (x base-kpa acc)expansion-alist-pkg-names015223,685549
(defun hons-union-ordered-string-lists (x y)hons-union-ordered-string-lists15238,686070
(defun expansion-alist-pkg-names-memoize (x)expansion-alist-pkg-names-memoize15255,686612
(defun expansion-alist-pkg-names (x base-kpa)expansion-alist-pkg-names15265,686923
(defun delete-names-from-kpa (names kpa)delete-names-from-kpa15296,688354
(defun print-certify-book-step-2 (ev-lst expansion-alist pcert0-file acl2x-fileprint-certify-book-step-215305,688636
(defun print-certify-book-step-3 (state)print-certify-book-step-315335,690334
(defun print-certify-book-guards-warningprint-certify-book-guards-warning15345,690756
(defun chk-certify-book-step-3 (post-alist2 post-alist1 ctx state)chk-certify-book-step-315373,691833
(defun print-certify-book-step-4 (full-book-name expansion-filename cert-opprint-certify-book-step-415437,695539
(defun print-certify-book-step-5 (full-book-name state)print-certify-book-step-515453,696221
(defun hcomp-build-from-portcullis (trips state)hcomp-build-from-portcullis15460,696478
(defstub acl2x-expansion-alist (expansion-alist state)acl2x-expansion-alist15559,701995
(defun hons-copy-with-state (x state)hons-copy-with-state15570,702470
(defun identity-with-state (x state)identity-with-state15575,702596
(defun write-acl2x-file (expansion-alist acl2x-file ctx state)write-acl2x-file15590,703063
(defun merge-into-expansion-alist1 (acl2x-expansion-alistmerge-into-expansion-alist115611,703822
(defun acl2x-alistp-domains-subsetp (x y)acl2x-alistp-domains-subsetp15638,705307
(defun merge-into-expansion-alist (acl2x-expansion-alistmerge-into-expansion-alist15651,705696
(defun restrict-expansion-alist (index expansion-alist)restrict-expansion-alist15677,706940
(defun elide-locals-from-expansion-alist (alist acc)elide-locals-from-expansion-alist15689,707351
(defun write-port-file (full-book-name cmds ctx state)write-port-file15705,708019
(defmacro save-parallelism-settings (form)save-parallelism-settings15734,709029
(defun include-book-alist-equal-modulo-local (old-post-alist new-post-alist)include-book-alist-equal-modulo-local15747,709479
(defun copy-object-channel-until-marker (marker ch-from ch-to state)copy-object-channel-until-marker15769,710671
(defun copy-pcert0-to-pcert1 (from to ctx state)copy-pcert0-to-pcert115779,711075
(defun touch? (filename old-filename ctx state)touch?15810,712549
(defun convert-book-name-to-compiled-name (full-book-name state)convert-book-name-to-compiled-name15847,714260
(defun certify-book-finish-convert (new-post-alist old-post-alistcertify-book-finish-convert15857,714666
(defun delete-cert-files (full-book-name)delete-cert-files15890,716369
(defun include-book-alist-uncertified-books (alist acc state)include-book-alist-uncertified-books15900,716728
(defun count-forms-in-channel (ch state n)count-forms-in-channel15937,718442
(defun skip-forms-in-channel (n ch state)skip-forms-in-channel15943,718651
(defun post-alist-from-pcert1-1 (n first-try-p pcert1-file msg ctx state)post-alist-from-pcert1-115950,718931
(defun post-alist-from-pcert1 (pcert1-file msg ctx state)post-alist-from-pcert115998,720639
(defun certificate-post-alist (pcert1-file cert-file full-book-name ctx state)certificate-post-alist16015,721113
(defun certify-book-finish-complete (full-book-name ctx state)certify-book-finish-complete16031,721858
(defun expansion-alist-conflict (acl2x-expansion-alistexpansion-alist-conflict16085,724228
(defun chk-absstobj-invariants (extra-msg state)chk-absstobj-invariants16117,725931
(defun certify-book-fn (user-book-name k compile-flg defaxioms-okpcertify-book-fn16172,728502
(defmacro certify-book (user-book-namecertify-book16994,777340
(defmacro certify-book! (user-book-name &optionalcertify-book!17239,791239
(defdoc provisional-certificationprovisional-certification17273,792650
(deflabel pathnamepathname17596,811188
(deflabel book-examplebook-example17641,813538
(deflabel full-book-namefull-book-name17812,822493
(deflabel book-namebook-name17857,824340
(deflabel book-contentsbook-contents17948,828591
(deflabel certificatecertificate18026,831898
(deflabel portcullisportcullis18109,836292
(deflabel versionversion18221,842399
(deflabel keepkeep18315,847402
(deflabel uncertified-booksuncertified-books18348,848972
(deflabel books-certification-classicbooks-certification-classic18411,852428
(defdoc books-certificationbooks-certification18656,864258
(defun redundant-defchoosep (name event-form wrld)redundant-defchoosep18924,876235
(defun chk-arglist-for-defchoose (args bound-vars-flg ctx state)chk-arglist-for-defchoose18938,876844
(defun defchoose-constraint-basic (fn bound-vars formals tbody ctx wrld state)defchoose-constraint-basic18956,877678
(defun generate-variable-lst-simple (var-lst avoid-lst)generate-variable-lst-simple18997,879019
(defun defchoose-constraint-extra (fn bound-vars formals body)defchoose-constraint-extra19014,879672
(defun defchoose-constraint (fn bound-vars formals body tbody strengthen ctxdefchoose-constraint19089,883545
(defun defchoose-fn (def state event-form)defchoose-fn19102,884120
(defun non-acceptable-defun-sk-p (name args body doc quant-ok rewrite exists-p)non-acceptable-defun-sk-p19272,892554
(defmacro defun-sk (name args bodydefun-sk19352,896554
(deflabel forallforall19725,913335
(deflabel existsexists19739,913726
(deflabel defun-sk-exampledefun-sk-example19753,914121
(defdoc quantifier-tutorialquantifier-tutorial19849,917615
(deflabel quantifiersquantifiers20452,945117
(deflabel quantifiers-using-recursionquantifiers-using-recursion20489,946876
(deflabel quantifiers-using-defun-skquantifiers-using-defun-sk20520,947709
(deflabel quantifiers-using-defun-sk-extendedquantifiers-using-defun-sk-extended20570,949335
(defun doublet-style-symbol-to-symbol-alistp (x)doublet-style-symbol-to-symbol-alistp20664,952465
(defun chk-legal-defstobj-name (name state)chk-legal-defstobj-name20677,952991
(defun chk-unrestricted-guards-for-user-fns (names wrld ctx state)chk-unrestricted-guards-for-user-fns20690,953471
(defconst *expt2-28* (expt 2 28))*expt2-28*20703,954018
(defun fix-stobj-array-type (type wrld)fix-stobj-array-type20705,954053
(defun chk-stobj-field-descriptor (name field-descriptor ctx wrld state)chk-stobj-field-descriptor20727,954907
(defun chk-acceptable-defstobj-renamingchk-acceptable-defstobj-renaming20911,964074
(defun defconst-name (name)defconst-name21041,970316
(defun chk-acceptable-defstobj1chk-acceptable-defstobj121046,970438
(defconst *defstobj-keywords**defstobj-keywords*21139,975418
(defun defstobj-redundancy-bundle (args)defstobj-redundancy-bundle21142,975492
(defun old-defstobj-redundancy-bundle (name wrld)old-defstobj-redundancy-bundle21176,976560
(defun redundant-defstobjp (name args wrld)redundant-defstobjp21189,977051
(defun congruent-stobj-fields (fields1 fields2)congruent-stobj-fields21215,978410
(defun chk-acceptable-defstobj (name args ctx wrld state)chk-acceptable-defstobj21226,978843
(defun defstobj-fields-template (field-descriptors renaming wrld)defstobj-fields-template21394,986669
(defun defstobj-template (name args wrld)defstobj-template21440,988670
(defun defstobj-component-recognizer-calls (ftemps n var ans)defstobj-component-recognizer-calls21486,990817
(defun defstobj-component-recognizer-axiomatic-defs (name template ftemps wrld)defstobj-component-recognizer-axiomatic-defs21513,991961
(defun defstobj-field-fns-axiomatic-defs (top-recog var n ftemps wrld)defstobj-field-fns-axiomatic-defs21585,995225
(defun defstobj-axiomatic-init-fields (ftemps wrld)defstobj-axiomatic-init-fields21699,1001003
(defun defstobj-creator-fn (creator-name field-templates wrld)defstobj-creator-fn21723,1001945
(defun defstobj-axiomatic-defs (name template wrld)defstobj-axiomatic-defs21733,1002237
(defun simple-array-type (array-etype dimensions)simple-array-type21772,1004024
(defun-one-output stobj-copy-array-aref (a1 a2 i n)stobj-copy-array-aref21784,1004409
(defun-one-output stobj-copy-array-svref (a1 a2 i n)stobj-copy-array-svref21802,1005120
(defun-one-output stobj-copy-array-fix-aref (a1 a2 i n)stobj-copy-array-fix-aref21817,1005577
(defmacro live-stobjp (name)live-stobjp21834,1006252
(defun array-etype-is-fixnum-type (array-etype)array-etype-is-fixnum-type21844,1006684
(defun defstobj-field-fns-raw-defs (var flush-var inline n ftemps)defstobj-field-fns-raw-defs21880,1008073
(defun defstobj-raw-init-fields (ftemps)defstobj-raw-init-fields22061,1016765
(defun defstobj-raw-init (template)defstobj-raw-init22118,1019264
(defun defstobj-raw-defs (name template congruent-stobj-rep wrld)defstobj-raw-defs22126,1019509
(defun put-stobjs-in-and-outs1 (name ftemps wrld)put-stobjs-in-and-outs122173,1021519
(defun put-stobjs-in-and-outs (name template wrld)put-stobjs-in-and-outs22219,1023185
(defun defconst-name-alist (lst n)defconst-name-alist22272,1025502
(defun accessor-array (name field-names)accessor-array22278,1025662
(defun strip-accessor-names (x)strip-accessor-names22288,1026081
(defun defstobj-defconsts (names index)defstobj-defconsts22298,1026328
(defun defstobj-fn (name args state event-form)defstobj-fn22304,1026513
(defun absstobj-name (name type)absstobj-name22752,1050824
(defmacro defabsstobj (&whole event-formdefabsstobj22781,1051980
(defmacro defabsstobj (&whole event-formdefabsstobj22892,1056670
(defun concrete-stobj (st wrld)concrete-stobj23549,1089101
(defmacro defabsstobj-missing-events (&whole event-formdefabsstobj-missing-events23557,1089380
(defun redundant-defabsstobjp (name event-form wrld)redundant-defabsstobjp23603,1091459
(defun absstobj-correspondence-concl-lst (stobjs-out i st$c corr-fn)absstobj-correspondence-concl-lst23607,1091621
(defun absstobj-correspondence-formula (f$a f$c corr-fn formals guard-pre stabsstobj-correspondence-formula23618,1092149
(defun absstobj-preserved-formula (f$a f$c formals guard-pre st st$c st$ap wrld)absstobj-preserved-formula23669,1094185
(defrec absstobj-methodabsstobj-method23719,1096067
(defun fn-stobj-updates-p (st fn wrld)fn-stobj-updates-p23738,1096780
(defun stobj-updates-p (st term wrld)stobj-updates-p23762,1097470
(defun stobj-updates-listp (st x wrld)stobj-updates-listp23837,1100270
(defun unprotected-export-p (st$c name wrld)unprotected-export-p23847,1100625
(defun translate-absstobj-field (st st$c field type protect-defaulttranslate-absstobj-field23851,1100770
(defun simple-translate-absstobj-fields (st st$c fields types protect-defaultsimple-translate-absstobj-fields24197,1120041
(defun one-way-unify-p (pat term)one-way-unify-p24219,1120996
(defun obviously-iff-equiv-terms (x y)obviously-iff-equiv-terms24229,1121259
(defun chk-defabsstobj-method-lemmas (method st st$c st$ap corr-fnchk-defabsstobj-method-lemmas24274,1123278
(defun chk-defabsstobj-method (method st st$c st$ap corr-fn congruent-tochk-defabsstobj-method24387,1128794
(defun chk-acceptable-defabsstobj1 (st st$c st$ap corr-fn fieldschk-acceptable-defabsstobj124411,1129851
(defun first-keyword (lst)first-keyword24458,1131815
(defun chk-acceptable-defabsstobj (name st$c recognizer st$ap creator corr-fnchk-acceptable-defabsstobj24465,1132002
(defun defabsstobj-axiomatic-defs (st$c methods)defabsstobj-axiomatic-defs24550,1135935
(defun defabsstobj-raw-def (method)defabsstobj-raw-def24570,1136982
(defun defabsstobj-raw-defs-rec (methods)defabsstobj-raw-defs-rec24620,1139114
(defun defabsstobj-raw-defs (st-name methods)defabsstobj-raw-defs24628,1139331
(defun expand-recognizer (st-name recognizer see-doc ctx state)expand-recognizer24664,1140962
(defun put-absstobjs-in-and-outs (st methods wrld)put-absstobjs-in-and-outs24679,1141625
(defun method-exec (name methods)method-exec24697,1142484
(defun defabsstobj-raw-init (creator-name methods)defabsstobj-raw-init24706,1142819
(defun defabsstobj-missing-msg (missing wrld)defabsstobj-missing-msg24709,1142913
(defun update-guard-post (logic-subst methods)update-guard-post24733,1144014
(defun defabsstobj-logic-subst (methods)defabsstobj-logic-subst24753,1145120
(defun chk-defabsstobj-guard (method ctx wrld state-vars)chk-defabsstobj-guard24759,1145380
(defun chk-defabsstobj-guards1 (methods msg ctx wrld state-vars)chk-defabsstobj-guards124784,1146659
(defun chk-defabsstobj-guards (methods congruent-to ctx wrld state)chk-defabsstobj-guards24800,1147393
(defun make-absstobj-logic-exec-pairs (methods)make-absstobj-logic-exec-pairs24812,1147973
(defun defabsstobj-fn1 (st-name st$c recognizer creator corr-fn exportsdefabsstobj-fn124818,1148257
(defun defabsstobj-fn (st-name st$c recognizer creator corr-fn exportsdefabsstobj-fn25035,1158872
(deflabel stobjstobj25055,1159937
(deflabel stobj-example-1stobj-example-125158,1165330
(deflabel declare-stobjsdeclare-stobjs25391,1174588
(deflabel stobj-example-1-defunsstobj-example-1-defuns25442,1176828
(deflabel stobj-example-1-implementationstobj-example-1-implementation25561,1181473
(deflabel stobj-example-1-proofsstobj-example-1-proofs25636,1184285
(deflabel stobj-example-2stobj-example-225786,1189845
(deflabel stobj-example-3stobj-example-325880,1192929
(defdoc resize-listresize-list26118,1201956
(defun-one-output mv-let-for-with-local-stobj (mv-let-form st creator flet-fns w)mv-let-for-with-local-stobj26132,1202476
(defmacro with-local-stobj (&rest args)with-local-stobj26198,1205849
(deflabel with-local-stobjwith-local-stobj26434,1212096
(defun create-state ()create-state26514,1215202
(defmacro with-local-state (mv-let-form)with-local-state26518,1215299
(defdoc nested-stobjsnested-stobjs26807,1227050
(defmacro stobj-let (&whole x &rest args)stobj-let27371,1252039
(defun push-untouchable-fn (name fn-p state doc event-form)push-untouchable-fn27380,1252234
(defun remove-untouchable-fn (name fn-p state doc event-form)remove-untouchable-fn27435,1254315
(defun def-body-lemmas (def-bodies lemmas)def-body-lemmas27490,1256499
(defmacro show-bodies (fn)show-bodies27498,1256809
(defun set-body-fn1 (rune def-bodies acc)set-body-fn127548,1258911
(defun set-body-fn (fn name-or-rune state event-form)set-body-fn27558,1259277
(defdoc tracetrace27604,1260936
(defparameter *trace-evisc-tuple**trace-evisc-tuple*27632,1262075
(defparameter *trace-evisc-tuple-world**trace-evisc-tuple-world*27635,1262117
(defun trace-evisc-tuple ()trace-evisc-tuple27638,1262165
(defun trace-multiplicity (name state)trace-multiplicity27647,1262434
(defun first-trace-printing-column (state)first-trace-printing-column27660,1262787
(defun trace-ppr (x trace-evisc-tuple msgp state)trace-ppr27676,1263276
(defvar *inside-trace$* nil)*inside-trace$*27687,1263576
(defun custom-trace-ppr (direction x &optional evisc-tuple msgp)custom-trace-ppr27690,1263623
(defun *1*defp (trace-spec wrld)*1*defp27751,1266221
(defun trace$-er-msg (fn)trace$-er-msg27756,1266367
(defun decls-and-doc (forms)decls-and-doc27760,1266463
(defun trace$-when-gcond (gcond form)trace$-when-gcond27770,1266739
(defun stobj-evisceration-alist (user-stobj-alist state)stobj-evisceration-alist27775,1266828
(defun trace-evisceration-alist (state)trace-evisceration-alist27783,1267223
(defun set-trace-evisc-tuple (val state)set-trace-evisc-tuple27787,1267381
(defun chk-trace-options-aux (form kwd formals ctx wrld state)chk-trace-options-aux27863,1270425
(defun trace$-value-msgp (x)trace$-value-msgp27890,1271607
(defun chk-trace-options (fn predefined trace-options formals ctx wrld state)chk-trace-options27903,1272054
(defun memoize-off-trace-error (fn ctx)memoize-off-trace-error27997,1276165
(defun untrace$-fn1 (fn state)untrace$-fn128005,1276526
(defun untrace$-rec (fns ctx state)untrace$-rec28056,1278492
(defun untrace$-fn (fns state)untrace$-fn28075,1279142
(defun maybe-untrace$-fn (fn state)maybe-untrace$-fn28086,1279533
(defmacro maybe-untrace$ (fn)maybe-untrace$28095,1279837
(defmacro maybe-untrace (fn)maybe-untrace28099,1279920
(defun maybe-untrace! (fn &optional verbose)maybe-untrace!28109,1280186
(defun increment-trace-level ()increment-trace-level28133,1280925
(defun trace$-def (arglist def trace-options predefined multiplicity ctx)trace$-def28139,1281106
(defun trace$-install (fn formals def trace-options predefined multiplicitytrace$-install28315,1289292
(defun oneified-def (fn wrld &optional trace-rec-for-none)oneified-def28347,1290614
(defun trace$-fn-general (trace-spec ctx state)trace$-fn-general28363,1291233
(defun trace$-fn-simple (trace-spec ctx state)trace$-fn-simple28555,1300443
(defconst *trace-keywords**trace-keywords*28558,1300542
(defconst *trace-keywords-needing-ttag**trace-keywords-needing-ttag*28567,1300790
(defun all-keywords-p (keywords)all-keywords-p28574,1301013
(defun first-assoc-keyword (keys x)first-assoc-keyword28580,1301173
(defconst *illegal-trace-spec-fmt-string**illegal-trace-spec-fmt-string*28588,1301452
(defun trace$-fn (trace-spec ctx state)trace$-fn28593,1301680
(defun trace$-lst (trace-spec-lst ctx state)trace$-lst28627,1303472
(defmacro trace$ (&rest trace-specs)trace$28638,1303817
(defmacro with-ubt! (form)with-ubt!29166,1327433
(defmacro trace! (&rest fns)trace!29186,1328249
(defmacro untrace$ (&rest fns)untrace$29427,1335744
(defun open-trace-file-fn (filename state)open-trace-file-fn29451,1336462
(defmacro open-trace-file (filename)open-trace-file29477,1337562
(defun close-trace-file-fn (quiet-p state)close-trace-file-fn29498,1338187
(defmacro close-trace-file ()close-trace-file29511,1338689
(defmacro break-on-error (&optional (on 't))break-on-error29527,1339158
(defun defexec-extract-key (x keyword result result-p)defexec-extract-key29628,1344071
(defun parse-defexec-dcls-1 (alist guard guard-p hints hints-p measureparse-defexec-dcls-129650,1345115
(defun fix-exec-xargs (exec-xargs hints hints-pfix-exec-xargs29773,1350556
(defun parse-defexec-dcls (dcls-and-strings finalparse-defexec-dcls29802,1351805
(defmacro defexec (&whole whole fn formals &rest rest)defexec29874,1355405
(defrec sar ; single-applicable-rewritesar30129,1366734
(defun applicable-rewrite-rules1 (term geneqv lemmas current-indexapplicable-rewrite-rules130144,1367578
(defun applicable-linear-rules1 (term lemmas current-index target-name-or-runeapplicable-linear-rules130204,1370170
(defun pc-relieve-hyp (rune hyp unify-subst type-alist wrld state ens ttree)pc-relieve-hyp30256,1372238
(defun pc-relieve-hyps1-iter (rune hyps unify-subst-lst unify-substpc-relieve-hyps1-iter30342,1375846
(defun pc-relieve-hyps1 (rune hyps unify-subst unify-subst0 ttree0 type-alistpc-relieve-hyps130363,1376832
(defun pc-relieve-hyps (rune hyps unify-subst type-alist keep-unify-subst wrldpc-relieve-hyps30414,1379235
(defun remove-trivial-lits (lst type-alist alist wrld ens ttree)remove-trivial-lits30427,1379834
(defun unrelieved-hyps (rune hyps unify-subst type-alist keep-unify-subst wrldunrelieved-hyps30450,1380883
(defun untranslate-subst-abb (sub abbreviations state)untranslate-subst-abb30474,1381899
(defun show-rewrite-linear (caller index col rune nume show-more subst-hypsshow-rewrite-linear30481,1382167
(defun show-rewrites-linears (caller app-rules col abbreviationsshow-rewrites-linears30574,1386888
(defun expand-assumptions-1 (term)expand-assumptions-130647,1389987
(defun expand-assumptions (x)expand-assumptions30662,1390631
(defun hyps-type-alist (assumptions ens wrld state)hyps-type-alist30672,1390862
(defun show-rewrites-linears-fn (caller rule-id enabled-only-flg ensshow-rewrites-linears-fn30686,1391523
(defun show-meta-lemmas1 (lemmas rule-id term wrld ens state)show-meta-lemmas130786,1396269
(defun show-meta-lemmas (term rule-id state)show-meta-lemmas30843,1398899
(defun decoded-type-set-from-tp-rule (tp unify-subst wrld ens)decoded-type-set-from-tp-rule30853,1399314
(defun show-type-prescription-rule (rule unify-subst type-alist abbreviationsshow-type-prescription-rule30873,1400078
(defun show-type-prescription-rules1 (rules term rule-id type-alistshow-type-prescription-rules130913,1402093
(defun show-type-prescription-rules (term rule-id abbreviations all-hyps ensshow-type-prescription-rules30935,1403133
(defun pl2-fn (form rule-id caller state)pl2-fn30967,1404559
(defun pl-fn (name state)pl-fn31025,1407476
(defmacro pl (name)pl31062,1408989
(defmacro pl2 (form rule-id)pl231108,1411204
(defun acl2-defaults-table-local-ctx-p (state)acl2-defaults-table-local-ctx-p31194,1416001
(defun add-include-book-dir-fn (keyword dir state)add-include-book-dir-fn31201,1416264
(defun delete-include-book-dir-fn (keyword state)delete-include-book-dir-fn31293,1420703
(defun add-custom-keyword-hint-fn (key uterm1 uterm2 state)add-custom-keyword-hint-fn31348,1423217
(defmacro reset-prehistory (&rest args)reset-prehistory31436,1427132
(defmacro reset-prehistory (&whole event-form &optional permanent-p doc)reset-prehistory31441,1427223
(defun checkpoint-world (flushp state)checkpoint-world31497,1429592
(defvar *checkpoint-world-len-and-alist-stack**checkpoint-world-len-and-alist-stack*31504,1429698
(defmacro checkpoint-world-len-and-alist ()checkpoint-world-len-and-alist31507,1429753
(defun checkpoint-world1 (flushp wrld state)checkpoint-world131510,1429847
(defun checkpoint-world (flushp state)checkpoint-world31536,1430954
(defun reset-kill-ring (n state)reset-kill-ring31548,1431233
(defun reset-prehistory-fn (permanent-p state doc event-form)reset-prehistory-fn31587,1432873
(defun memoize-table-chk-commutative (str fn val ctx wrld)memoize-table-chk-commutative31649,1435700
(defun memoize-table-chk (key val wrld)memoize-table-chk31700,1438151
(defun remove-stobjs-in-by-position (lst stobjs-in)remove-stobjs-in-by-position31901,1447944
(defun alist-to-doublets (alist)alist-to-doublets31912,1448425
(defun print-gv1 (fn-guard-stobjsin-args state)print-gv131918,1448631
(defun print-gv-fn (evisc-tuple state)print-gv-fn31940,1449367
(defmacro print-gv (&key (evisc-tupleprint-gv31970,1450553
(defun disable-iprint-ar (state)disable-iprint-ar32132,1455983
(defun enable-iprint-ar (state)enable-iprint-ar32155,1457139
(defconst *iprint-actions**iprint-actions*32173,1457934
(defun set-iprint-fn1 (x state)set-iprint-fn132176,1458001
(defun set-iprint-fn (x state)set-iprint-fn32205,1459019
(defun set-iprint-hard-bound (n ctx state)set-iprint-hard-bound32217,1459482
(defun set-iprint-soft-bound (n ctx state)set-iprint-soft-bound32230,1459953
(defmacro set-iprint (&optional (action ':RESET ; default ignoredset-iprint32243,1460424
(defconst *evisc-tuple-sites**evisc-tuple-sites*32474,1470523
(defun set-site-evisc-tuple (site evisc-tuple ctx state)set-site-evisc-tuple32477,1470595
(defun chk-evisc-tuple (evisc-tuple ctx state)chk-evisc-tuple32507,1472083
(defun set-evisc-tuple-lst (keys evisc-tuple acc ctx state)set-evisc-tuple-lst32516,1472408
(defun set-evisc-tuple-fn1 (keys all-keys evisc-tuple acc ctx state)set-evisc-tuple-fn132527,1472856
(defun iprint-virginp (state)iprint-virginp32570,1474813
(defun set-evisc-tuple-fn (evisc-tupleset-evisc-tuple-fn32577,1475078
(defmacro set-evisc-tuple (evisc-tupleset-evisc-tuple32643,1478101
(defmacro top-level (form &rest declares)top-level32757,1483834
(defun translate-defattach-helpers (kwd-value-lst name-tree ctx wrld state)translate-defattach-helpers33427,1520681
(defconst *defattach-keys**defattach-keys*33485,1523125
(defun defattach-unknown-constraints-error (name wrld ctx state)defattach-unknown-constraints-error33491,1523262
(defun intersection-domains (a1 a2)intersection-domains33503,1523805
(defun process-defattach-args1 (args ctx wrld state erasures explicit-erasuresprocess-defattach-args133513,1524126
(defun duplicate-keysp-eq (alist)duplicate-keysp-eq33814,1539819
(defun split-at-first-keyword (args)split-at-first-keyword33824,1540121
(defun filter-for-attachment (attachment-alist helpers-lst attach-by-defaultfilter-for-attachment33839,1540621
(defconst *defattach-keys-plus-skip-checks**defattach-keys-plus-skip-checks*33861,1541756
(defun process-defattach-args (args ctx state)process-defattach-args33864,1541841
(defun prove-defattach-guards1 (i n attachment-alist-tail attachment-alistprove-defattach-guards133993,1547875
(defun prove-defattach-guards (attachment-alist helpers-lst ctx ens wrld state)prove-defattach-guards34059,1551022
(defun defattach-constraint-rec (alist full-alist proved-fnl-insts-alistdefattach-constraint-rec34088,1552293
(defun defattach-constraint (attachment-alist proved-fnl-insts-alist wrld ctxdefattach-constraint34157,1555441
(defun prove-defattach-constraint (goal event-names attachment-alistprove-defattach-constraint34167,1555909
(defun attachment-component-owner (g path)attachment-component-owner34418,1569099
(defun intersection1-eq (x y)intersection1-eq34447,1570573
(defun defattach-component-has-owner (g g0 comps)defattach-component-has-owner34456,1570906
(defun defattach-merge-into-component (g0 ext-succ0 comps0 ext-succ1 g1defattach-merge-into-component34472,1571698
(defun defattach-merge-components (g0 ext-succ0 comps0 ext-succ1 g1 comps1defattach-merge-components34588,1575664
(defun defattach-merge (r0 r1)defattach-merge34630,1577580
(defun defattach-merge-lst (r lst changedp)defattach-merge-lst34654,1578547
(defun defattach-merge-lst-lst (to-do done changedp)defattach-merge-lst-lst34672,1579310
(defun defattach-loop-error-msg (loop end)defattach-loop-error-msg34698,1580600
(defun defattach-loop-error (loop ctx state)defattach-loop-error34707,1580916
(defun defattach-close (records ctx state)defattach-close34714,1581199
(defun defattach-erase-components (components canonical-erased-fs)defattach-erase-components34723,1581533
(defun defattach-erase-p (record erasures canonical-erased-fs)defattach-erase-p34754,1583154
(defun defattach-erase1 (records attachments erasures canonical-erased-fsdefattach-erase134772,1583986
(defun defattach-erase (records attachments erasures wrld)defattach-erase34807,1585486
(defun collect-ext-anc (f records)collect-ext-anc34827,1586503
(defun extend-attachment-components (comps g0 ext-succ f g)extend-attachment-components34838,1586888
(defun component-path-extension (f comps)component-path-extension34878,1588937
(defun extend-attachment-record (pair f-canon g-canon rec)extend-attachment-record34895,1589769
(defun update-attachment-records1 (pair f-canon g-canon records)update-attachment-records134932,1591444
(defun update-attachment-records (pair f-canon g-canon records wrld ctx state)update-attachment-records34963,1592984
(defun attachment-records (attachments records wrld ctx state)attachment-records35000,1594900
(defun chk-defattach-loop (attachments erasures wrld ctx state)chk-defattach-loop35016,1595511
(defun defaxiom-supporter-msg-list (symbols wrld)defaxiom-supporter-msg-list35051,1597100
(defun chk-acceptable-defattach (args proved-fnl-insts-alist ctx wrld state)chk-acceptable-defattach35061,1597604
(defun attachment-cltl-cmd (erasures alist)attachment-cltl-cmd35172,1603085
(defun defattach-fn (args state event-form)defattach-fn35186,1603649
(defun chk-return-last-entry (key val wrld)chk-return-last-entry35269,1607992
(defdoc return-last-tablereturn-last-table35331,1610882
(defmacro defmacro-last (fn &key raw (top-level-ok 't))defmacro-last35357,1612184
(defdoc printing-to-stringsprinting-to-strings35380,1613081
(defconst *fmt-control-defaults**fmt-control-defaults*35438,1615924
(defconst *fixed-fmt-controls**fixed-fmt-controls*35462,1617036
(defun fmt-control-bindings1 (alist fmt-control-defaults-tail)fmt-control-bindings135471,1617296
(defun fmt-control-bindings (alist)fmt-control-bindings35495,1618417
(defun set-iprint-ar (iprint-ar state)set-iprint-ar35500,1618584
(defmacro channel-to-string (form channel-varchannel-to-string35508,1618848
(defun fms-to-string-fn (str alist evisc-tuple fmt-control-alist iprint-action)fms-to-string-fn35615,1623391
(defmacro fms-to-string (str alist &key evisc-tuple fmt-control-alist iprint)fms-to-string35620,1623623
(defun fms!-to-string-fn (str alist evisc-tuple fmt-control-alist iprint-action)fms!-to-string-fn35624,1623832
(defmacro fms!-to-string (str alist &key evisc-tuple fmt-control-alist iprint)fms!-to-string35629,1624066
(defun fmt-to-string-fn (str alist evisc-tuple fmt-control-alist iprint-action)fmt-to-string-fn35633,1624277
(defmacro fmt-to-string (str alist &key evisc-tuple fmt-control-alist iprint)fmt-to-string35638,1624509
(defun fmt!-to-string-fn (str alist evisc-tuple fmt-control-alistfmt!-to-string-fn35642,1624718
(defmacro fmt!-to-string (str alist &key evisc-tuple fmt-control-alist iprint)fmt!-to-string35648,1624982
(defun fmt1-to-string-fn (str alist col evisc-tuple fmt-control-alistfmt1-to-string-fn35652,1625193
(defmacro fmt1-to-string (str alist col &key evisc-tuple fmt-control-alistfmt1-to-string35658,1625465
(defun fmt1!-to-string-fn (str alist col evisc-tuple fmt-control-alistfmt1!-to-string-fn35663,1625715
(defmacro fmt1!-to-string (str alist col &key evisc-tuple fmt-control-alistfmt1!-to-string35669,1625987
(defdoc dead-eventsdead-events35681,1626624
(defun attachment-pairs (fns wrld acc)attachment-pairs35822,1634390
(defun sibling-attachments (f wrld)sibling-attachments35834,1634726
(defun extended-ancestors4 (fns wrld fal)extended-ancestors435840,1634889
(defun extended-ancestors3 (components wrld fal)extended-ancestors335851,1635253
(defun extended-ancestors2 (canon-gs arfal wrld canon-gs-fal fal)extended-ancestors235866,1635793
(defun canonical-cdrs (alist wrld acc)canonical-cdrs35888,1636893
(defun extended-ancestors1 (fns canon-gs arfal wrld fal)extended-ancestors135895,1637144
(defun attachment-records-fal (attachment-records fal)attachment-records-fal35918,1638312
(defun extended-ancestors (f wrld)extended-ancestors35926,1638634
(defun ext-anc-attachment-missing (alist wrld)ext-anc-attachment-missing35940,1639170
(defun ext-anc-attachments-valid-p-1 (fns alist wrld)ext-anc-attachments-valid-p-135950,1639447
(defun ext-anc-attachments-valid-p (fns ext-anc-attachments wrld acc)ext-anc-attachments-valid-p35961,1639821
(defconst *inline-suffix* "$INLINE")*inline-suffix*35988,1641022
(defconst *inline-suffix-len-minus-1* (1- (length *inline-suffix*)))*inline-suffix-len-minus-1*35989,1641059
(defconst *notinline-suffix* "$NOTINLINE")*notinline-suffix*35990,1641128
(defconst *notinline-suffix-len-minus-1* (1- (length *notinline-suffix*)))*notinline-suffix-len-minus-1*35991,1641171
(defconst *non-stobj-var-root* (coerce (symbol-name 'non-stobj-var) 'list))*non-stobj-var-root*35992,1641246
(defun defun-inline-form (name formals lst defun-type suffix)defun-inline-form35994,1641323
(defmacro defun-inline (name formals &rest lst)defun-inline36024,1642574
(defmacro defund-inline (name formals &rest lst)defund-inline36142,1648069
(defmacro defun-notinline (name formals &rest lst)defun-notinline36156,1648516
(defmacro defund-notinline (name formals &rest lst)defund-notinline36178,1649564
(defun regenerate-tau-database-fn0 (user-auto-modep auto-modep ens tripsregenerate-tau-database-fn036192,1650027
(defun regenerate-tau-database-fn1regenerate-tau-database-fn136236,1652160
(defun regenerate-tau-database-fn (state doc event-form)regenerate-tau-database-fn36307,1655664
(defun rational-to-decimal-string (x state)rational-to-decimal-string36353,1657386
(defvar *time-tracker-alist* nil)*time-tracker-alist*36368,1657946
(defvar *time-tracker-disabled-p* nil)*time-tracker-disabled-p*36370,1657981
(defstruct time-trackertime-tracker36372,1658021
(defun tt-print-msg (tag msg total)tt-print-msg36401,1659307
(defun tt-init (tag times interval msg)tt-init36416,1659880
(defun tt-end (tag)tt-end36459,1661572
(defun tt-print? (tag min-time msg)tt-print?36469,1661912
(defun tt-stop (tag)tt-stop36521,1664328
(defun tt-start (tag)tt-start36543,1665191
(defun program-declared-p1 (dcls)program-declared-p136566,1666070
(defun program-declared-p (def)program-declared-p36576,1666407
(defmacro defund (&rest def)defund36588,1666826
(defmacro defund (&rest def)defund36644,1669010
(defun magic-ev-fncall-cl-proc (x)magic-ev-fncall-cl-proc36653,1669420
(defun-overrides magic-ev-fncall (fn args state hard-error-returns-nilp aok)magic-ev-fncall36678,1670109

ld.lisp,23815
(defun default-print-prompt (channel state)default-print-prompt27,1032
(defun print-prompt (prompt output-channel state)print-prompt133,5763
(defun initialize-timers (state)initialize-timers164,6996
(defun maybe-add-command-landmark (old-wrld old-default-defun-mode formmaybe-add-command-landmark171,7199
(defun replace-last-cdr (x val)replace-last-cdr229,9791
(defun ld-standard-oi-missing (val file-name ld-missing-input-ok ctx state)ld-standard-oi-missing234,9951
(defun chk-acceptable-ld-fn1-pair (pair ld-missing-input-ok ctx statechk-acceptable-ld-fn1-pair247,10578
(defun close-channels (channel-closing-alist state)close-channels396,17242
(defun chk-acceptable-ld-fn1 (alist ld-missing-input-ok ctx state co-stringchk-acceptable-ld-fn1431,18829
(defun chk-acceptable-ld-fn (alist state)chk-acceptable-ld-fn551,25219
(defun f-put-ld-specials (alist state)f-put-ld-specials592,27140
(defun f-get-ld-specials (state)f-get-ld-specials650,29553
(defun ld-read-keyword-command1 (n state)ld-read-keyword-command1690,31173
(defun exit-ld (state)exit-ld709,31897
(defun macro-minimal-arity1 (lst)macro-minimal-arity1718,32212
(defun macro-minimal-arity (sym default wrld)macro-minimal-arity725,32415
(defun ld-read-keyword-command (key state)ld-read-keyword-command731,32670
(defun ld-read-command (state)ld-read-command802,35594
(deflabel acl2-customizationacl2-customization838,37435
(deflabel keyword-commandskeyword-commands915,41586
(defun ld-print-command (keyp form col state)ld-print-command970,44057
(defun ld-filter-command (form state)ld-filter-command992,44638
(defun-one-output ppr? (x raw-x col channel state)ppr?1016,45888
(defun ld-print-results (trans-ans state)ld-print-results1029,46261
(defun ld-print-prompt (state)ld-print-prompt1138,50898
(defun good-bye-fn (status)good-bye-fn1154,51485
(defmacro good-bye (&optional (status '0))good-bye1160,51613
(defun ld-return-error (state)ld-return-error1197,52831
(defun initialize-accumulated-warnings ()initialize-accumulated-warnings1205,53087
(defun ld-read-eval-print (state)ld-read-eval-print1210,53192
(defun ld-loop (state)ld-loop1344,59381
(defvar *first-entry-to-ld-fn-body-flg*)*first-entry-to-ld-fn-body-flg*1370,60522
(defun update-cbd (standard-oi0 state)update-cbd1372,60564
(defun ld-fn-body (standard-oi0 new-ld-specials-alist state)ld-fn-body1407,62178
(defun ld-fn1 (standard-oi0 alist state bind-flg)ld-fn11502,66601
(defun ld-fn-alist (alist state)ld-fn-alist1542,68525
(defmacro with-interrupts (&rest forms)with-interrupts1574,70027
(defun ld-fn0 (alist state bind-flg)ld-fn01591,70527
(defun ld-fn (alist state bind-flg)ld-fn1776,80539
(defmacro ld (standard-oild1836,82881
(defdoc calling-ld-in-bad-contextscalling-ld-in-bad-contexts2151,100435
(defmacro quick-test nilquick-test2190,102313
(defun wormhole-prompt (channel state)wormhole-prompt2214,103197
(defun reset-ld-specials-fn (reset-channels-flg state)reset-ld-specials-fn2226,103699
(defmacro reset-ld-specials (reset-channels-flg)reset-ld-specials2239,104239
(defun maybe-reset-defaults-table1maybe-reset-defaults-table12268,105562
(defun maybe-reset-defaults-table2maybe-reset-defaults-table22306,107198
(defun maybe-reset-defaults-table (pre-defaults-tbl post-defaults-tbl state)maybe-reset-defaults-table2315,107544
(defun delete-something (lst)delete-something2320,107846
(defun store-in-kill-ring (x0 ring)store-in-kill-ring2330,108173
(defun rotate-kill-ring1 (ring xn)rotate-kill-ring12350,109189
(defun rotate-kill-ring (ring xn)rotate-kill-ring2355,109356
(defun ubt-ubu-fn1 (kwd wrld pred-wrld state)ubt-ubu-fn12367,109902
(defun ubt-ubu-fn (kwd cd state)ubt-ubu-fn2422,112013
(defun ubt!-ubu!-fn (kwd cd state)ubt!-ubu!-fn2474,114411
(defmacro ubt-prehistory ()ubt-prehistory2491,114868
(defun ubt-prehistory-fn (state)ubt-prehistory-fn2504,115317
(defun oops-warning (state)oops-warning2540,116912
(defun oops-fn (state)oops-fn2554,117482
(defmacro oops niloops2581,118793
(defmacro i-am-here ()i-am-here2678,123223
(defun rebuild-fn-read-filter (file state)rebuild-fn-read-filter2712,124337
(defun rebuild-fn (file filter filterp dir state)rebuild-fn2744,125807
(defmacro rebuild (file &optional (filter 'nil filterp)rebuild2769,126601
(defconst *basic-sweep-error-str**basic-sweep-error-str*2975,137213
(defun sweep-symbol-binding-for-bad-symbol (sym obj deceased-packages state)sweep-symbol-binding-for-bad-symbol2982,137587
(defun sweep-global-lst (l deceased-packages state)sweep-global-lst3004,138604
(defun sweep-stack-entry-for-bad-symbol (name i obj deceased-packages state)sweep-stack-entry-for-bad-symbol3013,138924
(defun sweep-t-stack (i deceased-packages state)sweep-t-stack3036,139981
(defun sweep-acl2-oracle (i deceased-packages state)sweep-acl2-oracle3044,140295
(defun sweep-global-state-for-lisp-objects (deceased-packages state)sweep-global-state-for-lisp-objects3059,140829
(deflabel compilationcompilation3105,142523
(defdoc book-compiled-filebook-compiled-file3152,144684
(deflabel escape-to-common-lispescape-to-common-lisp3244,150360
(deflabel copyrightcopyright3259,150792
(deflabel acknowledgmentsacknowledgments3287,151795
(deflabel breaksbreaks3433,159046
(deflabel ordinalsordinals3478,161199
(defmacro wet (form &rest kwd-args)wet3620,168216
(defmacro disassemble$ (fn &rest argsdisassemble$3802,176740
(deflabel release-notesrelease-notes3860,179431
(deflabel note1note13872,179751
(deflabel note2note23893,180380
(deflabel note3note33927,182007
(deflabel note4note44029,187845
(deflabel note5note54190,194885
(deflabel note6note64437,207200
(deflabel note7note74562,212573
(deflabel note8note84761,221308
(deflabel note8-updatenote8-update5108,237104
(deflabel note9note95168,239323
(deflabel note-2-0note-2-05249,242380
(deflabel note-2-1note-2-15282,243603
(deflabel note-2-2note-2-25300,243983
(deflabel note-2-3note-2-35362,246869
(deflabel note-2-4note-2-45422,249166
(deflabel note-2-5note-2-55468,250719
(deflabel |NOTE-2-5(R)||NOTE-2-55798,267123
(deflabel note-2-6note-2-65814,267420
(deflabel note-2-6-new-functionalitynote-2-6-new-functionality5833,268076
(deflabel note-2-6-proofsnote-2-6-proofs6016,277117
(deflabel note-2-6-rulesnote-2-6-rules6128,282827
(deflabel note-2-6-guardsnote-2-6-guards6199,286189
(deflabel note-2-6-proof-checkernote-2-6-proof-checker6267,289225
(deflabel note-2-6-systemnote-2-6-system6293,290134
(deflabel note-2-6-othernote-2-6-other6340,292302
(deflabel |NOTE-2-6(R)||NOTE-2-66460,297859
(deflabel note-2-7note-2-76476,298186
(deflabel note-2-7-bug-fixesnote-2-7-bug-fixes6563,301725
(deflabel note-2-7-new-functionalitynote-2-7-new-functionality6850,316186
(deflabel note-2-7-proofsnote-2-7-proofs7006,324140
(deflabel note-2-7-rulesnote-2-7-rules7108,329615
(deflabel note-2-7-guardsnote-2-7-guards7129,330535
(deflabel note-2-7-proof-checkernote-2-7-proof-checker7159,331355
(deflabel note-2-7-systemnote-2-7-system7170,331638
(deflabel note-2-7-othernote-2-7-other7240,334715
(deflabel |NOTE-2-7(R)||NOTE-2-77413,343015
(deflabel note-2-8note-2-87438,343779
(deflabel note-2-8-bug-fixesnote-2-8-bug-fixes7601,350774
(deflabel note-2-8-new-functionalitynote-2-8-new-functionality8051,371825
(deflabel note-2-8-proofsnote-2-8-proofs8197,379974
(deflabel note-2-8-rulesnote-2-8-rules8274,384223
(deflabel note-2-8-guardsnote-2-8-guards8315,385983
(deflabel note-2-8-proof-checkernote-2-8-proof-checker8326,386205
(deflabel note-2-8-systemnote-2-8-system8359,387871
(deflabel note-2-8-ordinalsnote-2-8-ordinals8388,389155
(deflabel note-2-8-othernote-2-8-other8396,389303
(deflabel |NOTE-2-8(R)||NOTE-2-88472,392455
(deflabel note-2-9note-2-98489,392928
(deflabel |NOTE-2-9(R)||NOTE-2-99077,418499
(deflabel note-2-9-1note-2-9-19092,418826
(deflabel note-2-9-2note-2-9-29306,428171
(deflabel note-2-9-3note-2-9-39528,437919
(deflabel note-2-9-3-ppr-changenote-2-9-3-ppr-change9760,448491
(deflabel note-2-9-4note-2-9-410038,457022
(deflabel note-2-9-5note-2-9-510421,476341
(deflabel note-3-0note-3-010776,493113
(deflabel |NOTE-3-0(R)||NOTE-3-010803,494131
(deflabel note-3-0-1note-3-0-110818,494434
(deflabel |NOTE-3-0-1(R)||NOTE-3-0-111145,511148
(deflabel note-3-0-2note-3-0-211160,511461
(deflabel note-3-1note-3-111675,533893
(deflabel |NOTE-3-1(R)||NOTE-3-111690,534298
(deflabel note-3-2note-3-211706,534606
(deflabel |NOTE-3-2(R)||NOTE-3-212373,563784
(deflabel note-3-2-1note-3-2-112400,564681
(deflabel |NOTE-3-2-1(R)||NOTE-3-2-112676,578164
(deflabel note-3-3note-3-312689,578362
(deflabel |NOTE-3-3(R)||NOTE-3-313192,601531
(deflabel note-3-4note-3-413205,601725
(deflabel |NOTE-3-4(R)||NOTE-3-413956,637774
(deflabel note-3-5note-3-513976,638347
(deflabel |NOTE-3-5(R)||NOTE-3-514944,684090
(deflabel note-3-6note-3-615022,687059
(deflabel |NOTE-3-6(R)||NOTE-3-615478,706481
(deflabel note-3-6-1note-3-6-115491,706673
(deflabel note-4-0note-4-015540,708588
(deflabel |NOTE-4-0(R)||NOTE-4-016581,756467
(deflabel note-4-0-wormhole-changesnote-4-0-wormhole-changes16594,756652
(deflabel note-4-1note-4-116661,759183
(deflabel |NOTE-4-1(R)||NOTE-4-116821,766352
(deflabel note-4-2note-4-216834,766542
(deflabel |NOTE-4-2(R)||NOTE-4-217393,794464
(deflabel note-4-3note-4-317406,794652
(deflabel |NOTE-4-3(R)||NOTE-4-318229,829528
(deflabel note-5-0note-5-018242,829713
(deflabel note-6-0note-6-019471,886571
(deflabel note-6-1note-6-120018,912909
(deflabel note-6-2note-6-220431,931737
(deflabel note-6-3note-6-320932,956015
(deflabel the-methodthe-method21360,976638
(deflabel lplp21455,981923
(defun-one-output compiled-function-p! (fn)compiled-function-p!21523,985513
(defun compile-function (ctx fn0 state)compile-function21535,985969
(defun getpid$ ()getpid$21597,988226
(defun-one-output tmp-filename (dir suffix)tmp-filename21621,989052
(defun keep-tmp-files (state)keep-tmp-files21647,990085
(defun comp-fn (fns gcl-flg tmp-suffix state)comp-fn21650,990156
(defmacro comp (fns)comp21765,994446
(defmacro comp (fns)comp21770,994517
(defmacro comp-gcl (fns)comp-gcl21880,1000212
(defun scan-past-deeper-event-landmarks (depth wrld)scan-past-deeper-event-landmarks21899,1000940
(defun puffable-encapsulate-p (cddr-car-wrld)puffable-encapsulate-p21919,1001696
(defun puffable-command-blockp (wrld cmd-form)puffable-command-blockp21930,1002110
(defun puffable-command-numberp (i state)puffable-command-numberp21964,1003544
(defun puff-command-block (wrld ans restore-cbd ctx state)puff-command-block21979,1004084
(defun commands-back-to (wrld1 wrld2 ans)commands-back-to22117,1010787
(defun puffed-command-sequence (cd ctx wrld state)puffed-command-sequence22132,1011338
(defun puff-fn1 (cd state)puff-fn122155,1012220
(defun puff-report (caller new-cd1 new-cd2 cd state)puff-report22246,1016803
(defun puff-fn (cd state)puff-fn22259,1017395
(defun puff*-fn11 (ptr k i j state)puff*-fn1122263,1017526
(defun puff*-fn1 (ptr k state)puff*-fn122284,1018276
(defun puff*-fn (cd state)puff*-fn22312,1019604
(defmacro puff (cd)puff22380,1022662
(defmacro puff* (cd)puff*22513,1030419
(defmacro mini-proveall nilmini-proveall22591,1033484
(defmacro exit (&optional (status '0))exit22829,1040695
(defmacro quit (&optional (status '0))quit22840,1040889
(defmacro set-guard-checking (flg)set-guard-checking22851,1041083
(defun dmr-stop-fn (state)dmr-stop-fn23127,1053147
(defmacro dmr-stop ()dmr-stop23139,1053642
(defun dmr-start-fn (state)dmr-start-fn23143,1053756
(defmacro dmr-start ()dmr-start23165,1054675
(defconst *home-page**home-page*23169,1054792
(defconst *home-page-references**home-page-references*23635,1070572
(deflabel |Pages Written Especially for the Tours||Pages23648,1071129
(deflabel |Undocumented Topic||Undocumented23671,1072279
(deflabel |Common Lisp||Common23677,1072451
(deflabel |An Example Common Lisp Function Definition||An23727,1074485
(deflabel |The Tours||The23765,1075853
(deflabel |A Flying Tour of ACL2||A23808,1077868
(deflabel |About the ACL2 Home Page||About23851,1079839
(deflabel |A Walking Tour of ACL2||A23881,1081011
(deflabel |What Is ACL2(Q)||What23908,1082057
(deflabel |About Models||About23935,1082930
(deflabel |Models in Engineering||Models23962,1083714
(deflabel |The Falling Body Model||The23987,1084315
(deflabel |Corroborating Models||Corroborating24009,1085029
(deflabel |Models of Computer Hardware and Software||Models24054,1087062
(deflabel |A Typical State||A24092,1088060
(deflabel |Functions for Manipulating these Objects||Functions24119,1088944
(deflabel |Common Lisp as a Modeling Language||Common24152,1090059
(deflabel |Analyzing Common Lisp Models||Analyzing24189,1091588
(deflabel |What is a Mathematical Logic(Q)||What24229,1093002
(deflabel |A Trivial Proof||A24254,1093819
(deflabel |What is a Mechanical Theorem Prover(Q)||What24263,1094033
(deflabel |What is a Mechanical Theorem Prover(Q) (cont)||What24285,1094841
(deflabel |ACL2 as an Interactive Theorem Prover||ACL224299,1095271
(deflabel |ACL2 as an Interactive Theorem Prover (cont)||ACL224312,1095741
(deflabel |ACL2 System Architecture||ACL224343,1097094
(deflabel |Modeling in ACL2||Modeling24368,1098215
(deflabel |Running Models||Running24394,1099011
(deflabel |Symbolic Execution of Models||Symbolic24426,1100101
(deflabel |Proving Theorems about Models||Proving24451,1100719
(deflabel |What is Required of the User(Q)||What24488,1102020
(deflabel |How Long Does It Take to Become an Effective User(Q)||How24519,1102960
(deflabel |Other Requirements||Other24541,1103888
(deflabel |The End of the Flying Tour||The24570,1104639
(deflabel |An Example of ACL2 in Use||An24587,1104985
(deflabel |How To Find Out about ACL2 Functions||How24638,1107204
(deflabel |How To Find Out about ACL2 Functions (cont)||How24668,1108368
(deflabel |The Admission of App||The24701,1109673
(deflabel |A Tiny Warning Sign||A24746,1111096
(deflabel |Revisiting the Admission of App||Revisiting24765,1111761
(deflabel |Evaluating App on Sample Input||Evaluating24806,1113188
(deflabel |Conversion||Conversion|24848,1114164
(deflabel |The Associativity of App||The24879,1115624
(deflabel |The Theorem that App is Associative||The24921,1117018
(deflabel |Free Variables in Top-Level Input||Free24953,1118304
(deflabel |The Proof of the Associativity of App||The24997,1120020
(deflabel |Name the Formula Above||Name25054,1122924
(deflabel |Perhaps||Perhaps|25063,1123189
(deflabel |Suggested Inductions in the Associativity of App Example||Suggested25072,1123424
(deflabel |Subsumption of Induction Candidates in App Example||Subsumption25095,1124095
(deflabel |Flawed Induction Candidates in App Example||Flawed25118,1124809
(deflabel |The Induction Scheme Selected for the App Example||The25141,1125467
(deflabel |The Induction Step in the App Example||The25162,1126207
(deflabel |The Base Case in the App Example||The25191,1127023
(deflabel |The Justification of the Induction Scheme||The25212,1127553
(deflabel |The Instantiation of the Induction Scheme||The25223,1127903
(deflabel |Nontautological Subgoals||Nontautological25236,1128365
(deflabel |Overview of the Simplification of the Induction Step to T||Overview25247,1128811
(deflabel |On the Naming of Subgoals||On25278,1129956
(deflabel |Overview of the Expansion of ENDP in the Induction Step||Overview25290,1130418
(deflabel |The Expansion of ENDP in the Induction Step (Step 0)||The25303,1131020
(deflabel |The Expansion of ENDP in the Induction Step (Step 1)||The25322,1131640
(deflabel |The Expansion of ENDP in the Induction Step (Step 2)||The25342,1132290
(deflabel |Overview of the Simplification of the Induction Conclusion||Overview25363,1132894
(deflabel |The Simplification of the Induction Conclusion (Step 0)||The25374,1133431
(deflabel |The Simplification of the Induction Conclusion (Step 1)||The25392,1134016
(deflabel |The Simplification of the Induction Conclusion (Step 2)||The25418,1135080
(deflabel |The Simplification of the Induction Conclusion (Step 3)||The25439,1135771
(deflabel |The Simplification of the Induction Conclusion (Step 4)||The25458,1136402
(deflabel |The Simplification of the Induction Conclusion (Step 5)||The25480,1137232
(deflabel |The Simplification of the Induction Conclusion (Step 6)||The25502,1138007
(deflabel |The Simplification of the Induction Conclusion (Step 7)||The25524,1138753
(deflabel |The Simplification of the Induction Conclusion (Step 8)||The25546,1139472
(deflabel |The Simplification of the Induction Conclusion (Step 9)||The25568,1140285
(deflabel |The Simplification of the Induction Conclusion (Step 10)||The25592,1141158
(deflabel |The Simplification of the Induction Conclusion (Step 11)||The25612,1141860
(deflabel |The Simplification of the Induction Conclusion (Step 12)||The25631,1142493
(deflabel |Overview of the Simplification of the Base Case to T||Overview25651,1143033
(deflabel |Overview of the Expansion of ENDP in the Base Case||Overview25679,1143874
(deflabel |Overview of the Final Simplification in the Base Case||Overview25688,1144267
(deflabel |The Final Simplification in the Base Case (Step 0)||The25698,1144632
(deflabel |The Final Simplification in the Base Case (Step 1)||The25716,1145236
(deflabel |The Final Simplification in the Base Case (Step 2)||The25733,1145775
(deflabel |The Final Simplification in the Base Case (Step 3)||The25749,1146231
(deflabel |The End of the Proof of the Associativity of App||The25768,1146772
(deflabel |Popping out of an Inductive Proof||Popping25798,1147656
(deflabel |The Q.E.D. Message||The25808,1148036
(deflabel |The Rules used in the Associativity of App Proof||The25817,1148319
(deflabel |The Time Taken to do the Associativity of App Proof||The25832,1149062
(deflabel |Guiding the ACL2 Theorem Prover||Guiding25848,1149753
(deflabel |Rewrite Rules are Generated from DEFTHM Events||Rewrite25875,1150736
(deflabel |You Must Think about the Use of a Formula as a Rule||You25909,1151695
(deflabel |Using the Associativity of App to Prove a Trivial Consequence||Using25939,1152703
(deflabel |Overview of the Proof of a Trivial Consequence||Overview25959,1153339
(deflabel |The WARNING about the Trivial Consequence||The26010,1155014
(deflabel |The First Application of the Associativity Rule||The26031,1155899
(deflabel |A Sketch of How the Rewriter Works||A26050,1156603
(deflabel |The Summary of the Proof of the Trivial Consequence||The26084,1157842
(deflabel |The End of the Walking Tour||The26096,1158218
(deflabel |ACL2 is an Untyped Language||ACL226129,1159307
(deflabel |Hey Wait!  Is ACL2 Typed or Untyped(Q)||Hey26156,1160433
(deflabel |Guards||Guards|26181,1161383
(deflabel |About the Prompt||About26218,1163118
(deflabel |The Event Summary||The26286,1166841
(deflabel |About the Admission of Recursive Definitions||About26333,1169155
(deflabel |About Types||About26364,1170801
(deflabel |Numbers in ACL2||Numbers26409,1173169
(deflabel |ACL2 Characters||ACL226464,1175470
(deflabel |ACL2 Strings||ACL226483,1176295
(deflabel |ACL2 Symbols||ACL226501,1177143
(deflabel |ACL2 Conses or Ordered Pairs||ACL226546,1179817
(deflabel |Guessing the Type of a Newly Admitted Function||Guessing26579,1181328
(defconst *meta-level-function-problem-1**meta-level-function-problem-1*26624,1183297
(defconst *meta-level-function-problem-1a**meta-level-function-problem-1a*26628,1183496
(defconst *meta-level-function-problem-1b**meta-level-function-problem-1b*26632,1183706
(defconst *meta-level-function-problem-1c**meta-level-function-problem-1c*26637,1183933
(defconst *meta-level-function-problem-1d**meta-level-function-problem-1d*26643,1184262
(defconst *meta-level-function-problem-1e**meta-level-function-problem-1e*26650,1184623
(defconst *meta-level-function-problem-2**meta-level-function-problem-2*26656,1184941
(defconst *meta-level-function-problem-3**meta-level-function-problem-3*26663,1185295
(defun acl2-magic-mfc (x)acl2-magic-mfc26683,1186488
(defun mfc-ts-raw (term mfc state forcep)mfc-ts-raw26737,1188382
(defun mfc-rw-raw (term alist obj equiv-info mfc fn state forcep)mfc-rw-raw26819,1192020
(defun mfc-relieve-hyp-raw (hyp alist rune target bkptr mfc statemfc-relieve-hyp-raw26901,1196236
(defun-one-output mfc-ap-raw (term mfc state forcep)mfc-ap-raw27009,1201804
(defmacro mfc-ts (term mfc st &keymfc-ts27115,1208000
(defmacro mfc-rw (term obj equiv-info mfc st &keymfc-rw27124,1208321
(defmacro mfc-rw+ (term alist obj equiv-info mfc st &keymfc-rw+27142,1209163
(defmacro mfc-relieve-hyp (hyp alist rune target bkptr mfc st &keymfc-relieve-hyp27151,1209558
(defmacro mfc-ap (term mfc st &keymfc-ap27162,1210054
(defun congruence-rule-listp (x wrld)congruence-rule-listp27167,1210230
(defun term-alistp-failure-msg (alist wrld)term-alistp-failure-msg27180,1210694
(defun find-runed-linear-lemma (rune lst)find-runed-linear-lemma27197,1211396
(defun mfc-force-flg (forcep mfc)mfc-force-flg27208,1211740
(defun update-rncst-for-forcep (forcep rcnst)update-rncst-for-forcep27213,1211888
(defun trans-eval-lst (lst ctx state aok)trans-eval-lst27263,1214035
(defun print-saved-output (inhibit-output-lst gag-mode state)print-saved-output27269,1214251
(defmacro pso ()pso27312,1216125
(defmacro psog ()psog27327,1216600
(defmacro pso! ()pso!27341,1216985
(defdoc nil-goalnil-goal27356,1217470
(defmacro set-saved-output (save-flg inhibit-flg)set-saved-output27395,1219747
(defmacro set-raw-proof-format (flg)set-raw-proof-format27500,1225510
(defmacro set-print-clause-ids (flg)set-print-clause-ids27527,1226577
(defun set-standard-co-state (val state)set-standard-co-state27575,1228604
(defun set-proofs-co-state (val state)set-proofs-co-state27584,1228939
(defmacro with-standard-co-and-proofs-co-to-file (filename form)with-standard-co-and-proofs-co-to-file27593,1229268
(defmacro wof (filename form) ; Acronym: With Output Filewof27617,1230135
(defmacro psof (filename)psof27643,1230997
(defun set-gag-mode-fn (action state)set-gag-mode-fn27678,1232702
(defmacro set-gag-mode (action)set-gag-mode27709,1233834
(defparameter *initial-cbd* nil)*initial-cbd*27819,1239233
(defvar *return-from-lp* nil)*return-from-lp*27822,1239284
(defun save-exec-fn (exec-filename extra-startup-string host-lisp-argssave-exec-fn27824,1239315
(defmacro save-exec (exec-filename extra-startup-stringsave-exec27886,1241827
(defdoc command-linecommand-line28164,1254612
(deflabel about-acl2about-acl228179,1255078
(defun defun-for-state-name (name)defun-for-state-name28206,1255897
(defmacro defun-for-state (name args)defun-for-state28211,1256027
(defun set-ld-evisc-tuple (val state)set-ld-evisc-tuple28221,1256353
(defun-for-state set-ld-evisc-tuple (val state))set-ld-evisc-tuple28226,1256480
(defun set-abbrev-evisc-tuple (val state)set-abbrev-evisc-tuple28228,1256530
(defun-for-state set-abbrev-evisc-tuple (val state))set-abbrev-evisc-tuple28233,1256665
(defun set-gag-mode-evisc-tuple (val state)set-gag-mode-evisc-tuple28235,1256719
(defun-for-state set-gag-mode-evisc-tuple (val state))set-gag-mode-evisc-tuple28240,1256858
(defun set-term-evisc-tuple (val state)set-term-evisc-tuple28242,1256914
(defun-for-state set-term-evisc-tuple (val state))set-term-evisc-tuple28247,1257045
(defun without-evisc-fn (form state)without-evisc-fn28249,1257097
(defmacro without-evisc (form)without-evisc28260,1257500

proof-checker-b.lisp,18559
(defmacro install-new-pc-meta-or-macro (command-type raw-name name formals doc body)install-new-pc-meta-or-macro23,881
(defun define-pc-meta-or-macro-fn (command-type raw-name formals body)define-pc-meta-or-macro-fn27,1084
(defmacro define-pc-meta (raw-name formals &rest body)define-pc-meta41,1553
(defmacro define-pc-macro (raw-name formals &rest body)define-pc-macro56,2123
(defmacro define-pc-atomic-macro (raw-name formals &rest body)define-pc-atomic-macro95,3725
(defmacro toggle-pc-macro (name &optional new-tp)toggle-pc-macro98,3857
(defmacro define-pc-primitive (raw-name formals &rest body)define-pc-primitive126,4867
(define-pc-primitive comment (&rest x)comment150,5925
(defun non-bounded-nums (nums lower upper)non-bounded-nums169,6340
(defun delete-by-position (lst current-index nums)delete-by-position182,6807
(define-pc-primitive drop (&rest nums)drop192,7191
(define-pc-meta lisp (form)lisp232,8583
(define-pc-primitive fail-primitive ()fail-primitive296,11125
(define-pc-macro fail (&optional hard)fail300,11213
(define-pc-macro illegal (instr)illegal322,11807
(defun chk-assumption-free-ttree-1 (ttree ctx)chk-assumption-free-ttree-1344,12485
(defun put-cdr-assoc-query-id (id val alist)put-cdr-assoc-query-id358,12997
(defun set-query-val (id val state)set-query-val364,13251
(defmacro query-on-exit (&optional (val 'toggle))query-on-exit377,13662
(defun replay-query (state)replay-query380,13760
(define-pc-meta exit (&optional event-name rule-classes do-it-flg)exit393,14482
(define-pc-meta undo (&optional n)undo559,23291
(define-pc-meta restore ()restore613,25261
(defun print-commands (indexed-instrs state)print-commands644,26364
(defun make-pretty-start-instr (state-stack)make-pretty-start-instr659,26962
(defun raw-indexed-instrs (start-index finish-index state-stack)raw-indexed-instrs669,27320
(define-pc-macro sequence-no-restore (instr-list)sequence-no-restore686,28305
(define-pc-macro skip ()skip689,28409
(defmacro define-pc-help (name args &rest body)define-pc-help702,28655
(defun evisc-indexed-instrs-1 (name rev-indexed-instrs)evisc-indexed-instrs-1737,29996
(defun evisc-indexed-instrs-rec (rev-indexed-instrs)evisc-indexed-instrs-rec749,30539
(defun mark-unfinished-instrs (indexed-instrs)mark-unfinished-instrs769,31512
(defun evisc-indexed-instrs (indexed-instrs)evisc-indexed-instrs785,32308
(define-pc-help commands (&optional n evisc-p)commands791,32576
(define-pc-macro comm (&optional n)comm833,34213
(defun promote-guts (pc-state goals hyps x y no-flatten-flg)promote-guts889,36529
(define-pc-primitive promote (&optional do-not-flatten-flag)promote901,36905
(defun remove-by-indices (m indices lst)remove-by-indices940,38603
(define-pc-macro print (form &optional without-evisc)print952,39169
(defun bounded-integer-listp (i j lst)bounded-integer-listp984,40410
(defun fetch-term-and-cl (term addr cl)fetch-term-and-cl997,40825
(defun fetch-term (term addr)fetch-term1039,42965
(defun governors (term addr)governors1049,43292
(defun term-id-iff (term address iff-flg)term-id-iff1057,43584
(defmacro ? (x)?1105,45860
(defstub ?-fn (x)?-fn1108,45892
(defun abbreviations-alist (abbreviations)abbreviations-alist1115,46102
(defun chk-?s (term ctx state)chk-?s1124,46365
(defun chk-?s-lst (term-lst ctx state)chk-?s-lst1145,47243
(defun remove-?s (term abbreviations-alist ctx state)remove-?s1153,47432
(defun translate-abb (x abbreviations ctx state)translate-abb1158,47619
(defmacro trans0 (x &optional abbreviations ctx)trans01171,47950
(defun p-body (conc current-addr abbreviations state)p-body1174,48063
(define-pc-help p ()p1182,48415
(define-pc-help pp ()pp1205,49111
(defun take-by-indices (m indices lst)take-by-indices1224,49633
(defun print-hyps (indexed-hyps ndigits abbreviations state)print-hyps1233,50002
(defun some-> (lst n)some->1246,50629
(defun print-hyps-top (indexed-hyps abbreviations state)print-hyps-top1255,50876
(defun print-governors-top (indexed-hyps abbreviations state)print-governors-top1264,51241
(defun pair-indices (seed indices lst)pair-indices1273,51600
(define-pc-macro hyps (&optional hyps-indices govs-indices)hyps1289,52268
(define-pc-primitive demote (&rest rest-args)demote1407,57646
(defun pair-keywords (keywords lst)pair-keywords1463,59949
(defun null-pool (pool)null-pool1478,60586
(defun initial-pspv (term displayed-goal otf-flg ens wrld splitter-output)initial-pspv1485,60753
(defun pc-prove (term displayed-goal hints otf-flg ens wrld ctx state)pc-prove1493,61070
(defun sublis-equal (alist tree)sublis-equal1516,62109
(defun abbreviations-alist-? (abbreviations)abbreviations-alist-?1526,62392
(defun find-?-fn (x)find-?-fn1536,62795
(defun unproved-pc-prove-clauses (ttree)unproved-pc-prove-clauses1546,63103
(defun prover-call (comm term-to-prove rest-args pc-state state)prover-call1549,63201
(defun make-new-goals (cl-set goal-name start-index)make-new-goals1622,67505
(defun same-goal (goal1 goal2)same-goal1634,68017
(defun remove-byes-from-tag-tree (ttree)remove-byes-from-tag-tree1640,68213
(define-pc-primitive prove (&rest rest-args)prove1643,68296
(defun add-string-val-pair-to-string-val-alist (key key1 val alist)add-string-val-pair-to-string-val-alist1725,71674
(defconst *bash-skip-forcing-round-hints**bash-skip-forcing-round-hints*1743,72475
(define-pc-atomic-macro bash (&rest hints)bash1761,72985
(define-pc-primitive dive (n &rest rest-addr)dive1813,75035
(define-pc-atomic-macro split ()split1874,77464
(define-pc-primitive add-abbreviation (var &optional raw-term)add-abbreviation1916,79190
(defun not-in-domain-eq (lst alist)not-in-domain-eq1982,82213
(define-pc-primitive remove-abbreviations (&rest vars)remove-abbreviations1993,82579
(defun print-abbreviations (vars abbreviations state)print-abbreviations2035,84310
(define-pc-help show-abbreviations (&rest vars)show-abbreviations2079,85994
(defun drop-from-end (n l)drop-from-end2114,87347
(define-pc-primitive up (&optional n)up2121,87587
(define-pc-atomic-macro top ()top2161,89346
(defmacro expand-address-recurseexpand-address-recurse2181,90062
(defmacro dive-once-more-error ()dive-once-more-error2196,90613
(defun abbreviation-raw-term-p (x)abbreviation-raw-term-p2203,90886
(defmacro addr-recur (pos b)addr-recur2207,90964
(defun or-addr (n term iff-flg)or-addr2222,91485
(defun and-addr (n term iff-flg)and-addr2272,93359
(defmacro add-dive-into-macro (name val)add-dive-into-macro2330,95812
(defmacro remove-dive-into-macro (name)remove-dive-into-macro2345,96283
(defun dive-into-macros-table (wrld)dive-into-macros-table2361,96847
(defun rassoc-eq-as-car (key alist)rassoc-eq-as-car2405,98665
(defun expand-address (addr raw-term term abbreviations iff-flgexpand-address2411,98842
(defmacro dv-error (str alist)dv-error2773,116784
(define-pc-atomic-macro dv (&rest rest-args)dv2783,117128
(defun deposit-term (term addr subterm)deposit-term2880,120369
(defun deposit-term-lst (lst n addr subterm)deposit-term-lst2890,120722
(defun geneqv-at-subterm (term addr geneqv ens wrld)geneqv-at-subterm2908,121437
(defun geneqv-at-subterm-top (term addr ens wrld)geneqv-at-subterm-top2927,122208
(defun maybe-truncate-current-address (addr term orig-addr acc state)maybe-truncate-current-address2970,124020
(defun deposit-term-in-goal (given-goal conc current-addr new-term state)deposit-term-in-goal2998,125249
(defun split-implies (term)split-implies3017,126012
(defun equiv-refinementp (equiv1 equiv2 wrld)equiv-refinementp3030,126475
(defun find-equivalence-hyp-term (term hyps target equiv w)find-equivalence-hyp-term3034,126616
(defun flatten-ands-in-lit-lst (x)flatten-ands-in-lit-lst3055,127504
(define-pc-primitive equiv (x y &optional equiv)equiv3061,127656
(define-pc-primitive casesplitcasesplit3173,133057
(define-pc-macro top? ()top?3270,137522
(define-pc-macro contrapose-last ()contrapose-last3276,137633
(define-pc-macro drop-last ()drop-last3284,137906
(define-pc-macro drop-conc ()drop-conc3292,138161
(define-pc-atomic-macro claim (expr &rest rest-args)claim3295,138247
(define-pc-atomic-macro induct (&optional raw-term)induct3362,141231
(defun print-on-separate-lines (vals evisc-tuple chan state)print-on-separate-lines3401,142694
(define-pc-help goals ()goals3411,143107
(defun modified-error-triple-for-sequence (erp val success-expr state)modified-error-triple-for-sequence3430,143660
(define-pc-meta sequencesequence3467,145520
(define-pc-macro negate (&rest instr-list)negate3593,152166
(define-pc-macro succeed (&rest instr-list)succeed3615,152831
(define-pc-macro do-all (&rest instr-list)do-all3637,153453
(define-pc-macro do-strict (&rest instr-list)do-strict3664,154400
(define-pc-macro do-all-no-prompt (&rest instr-list)do-all-no-prompt3682,154937
(define-pc-macro th (&optional hyps-indices govs-indices)th3700,155510
(define-pc-macro protect (&rest instr-list)protect3732,156745
(defun extract-goal (name goals)extract-goal3751,157347
(define-pc-primitive change-goal (&optional name end-flg)change-goal3761,157726
(define-pc-macro cg (&optional name)cg3814,159975
(defun change-by-position (lst index new)change-by-position3830,160384
(define-pc-primitive contrapose (&optional n)contrapose3840,160748
(define-pc-macro contradict (&optional n)contradict3880,162542
(define-pc-atomic-macro pro ()pro3889,162717
(define-pc-atomic-macro nx ()nx3904,163092
(define-pc-atomic-macro bk ()bk3929,163945
(define-pc-help p-top ()p-top3960,165036
(define-pc-macro repeat (instr)repeat3998,166603
(define-pc-macro repeat-rec (instr)repeat-rec4016,167077
(defmacro define-pc-bind (name args &optional doc-string declare-form)define-pc-bind4024,167237
(define-pc-bind quietquiet4041,167943
(define-pc-bind noise (inhibit-output-lst nil)noise4059,168351
(defun find-equivalence-hyp-term-no-target (index term hyps equiv w)find-equivalence-hyp-term-no-target4078,168995
(define-pc-atomic-macro if-not-proved (goal-name cmd)if-not-proved4104,170259
(define-pc-atomic-macro = (&optional x y &rest rest-args)=4123,170948
(define-pc-macro set-success (instr form)set-success4325,180982
(define-pc-macro orelse (instr1 instr2)orelse4328,181071
(defun applicable-rewrite-rules (current-term conc current-addr target-name-or-runeapplicable-rewrite-rules4348,181666
(define-pc-help show-rewrites (&optional rule-id enabled-only-flg)show-rewrites4367,182631
(define-pc-macro sr (&rest args)sr4411,184734
(define-pc-help show-linears (&optional rule-id enabled-only-flg)show-linears4426,185025
(define-pc-macro sls (&rest args)sls4457,186256
(define-pc-macro pl (&optional x)pl4474,186748
(define-pc-macro pr (&optional x)pr4508,188003
(define-pc-help show-type-prescriptions (&optional rule-id)show-type-prescriptions4542,189258
(define-pc-macro st (&rest args)st4569,190347
(defun translate-subst-abb1 (sub abbreviations state)translate-subst-abb14584,190661
(defun single-valued-symbolp-alistp (alist)single-valued-symbolp-alistp4607,191795
(defun check-cars-are-variables (alist state)check-cars-are-variables4614,192017
(defun translate-subst-abb (sub abbreviations state)translate-subst-abb4633,192795
(defun make-rewrite-instr (lemma-id raw-subst instantiate-free)make-rewrite-instr4664,194079
(define-pc-primitive rewrite (&optional rule-id raw-sub instantiate-free)rewrite4671,194343
(defun applicable-linear-rules (current-term target-name-or-runeapplicable-linear-rules4926,207783
(defun make-linear-instr (lemma-id raw-subst instantiate-free)make-linear-instr4940,208358
(define-pc-primitive apply-linear (&optional rule-id raw-sub instantiate-free)apply-linear4947,208620
(define-pc-macro al (&rest args)al5192,221245
(defun pc-help-fn (name state)pc-help-fn5205,221478
(defmacro state-only (triple)state-only5251,223676
(define-pc-help help (&optional instr)help5257,223810
(defun pc-help!-fn (name state)pc-help!-fn5322,226487
(define-pc-help help! (&optional instr)help!5364,228405
(define-pc-macro help-long (&rest args)help-long5378,228907
(define-pc-help more ()more5389,229175
(define-pc-help more! ()more!5401,229432
(defun pc-rewrite*-1pc-rewrite*-15412,229744
(defun pc-rewrite*pc-rewrite*5456,231824
(defun make-goals-from-assumptions (assumptions conc hyps current-addr goal-name start-index)make-goals-from-assumptions5470,232371
(defun make-new-goals-from-assumptions (assumptions goal)make-new-goals-from-assumptions5483,232947
(defconst *default-s-repeat-limit* 10)*default-s-repeat-limit*5493,233268
(define-pc-primitive s (&rest args)s5495,233308
(defun build-pc-enabled-structure-from-ens (new-suffix ens)build-pc-enabled-structure-from-ens5752,245516
(define-pc-primitive in-theory (&optional theory-expr)in-theory5779,246775
(define-pc-atomic-macro s-prop (&rest names)s-prop5871,250920
(define-pc-atomic-macro x (&rest args)x5894,251679
(define-pc-primitive expand (&optionalexpand5953,254002
(define-pc-atomic-macro x-dumb ()x-dumb6050,257694
(define-pc-macro bookmark (tag &rest instr-list)bookmark6065,258106
(defun change-last (lst val)change-last6086,258832
(defun assign-event-name-and-rule-classes (event-name rule-classes state)assign-event-name-and-rule-classes6094,259009
(defun save-fn (name ss-alist state)save-fn6110,259809
(define-pc-macro save (&optional name do-it-flg)save6119,260041
(defmacro retrieve (&optional name)retrieve6167,262114
(define-pc-macro retrieve ()retrieve6185,262518
(defun unsave-fn (name state)unsave-fn6211,263543
(defmacro unsave (name)unsave6215,263645
(define-pc-help unsave (&optional name)unsave6233,264017
(defun show-retrieved-goal (state-stack state)show-retrieved-goal6267,265407
(defun retrieve-fn (name state)retrieve-fn6277,265804
(defun print-all-goals (goals state)print-all-goals6322,267789
(define-pc-help print-all-goals ()print-all-goals6328,267949
(defmacro print-conc (&optional acl2::goal)print-conc6340,268248
(defun print-all-concs (goals state)print-all-concs6352,268729
(define-pc-help print-all-concs ()print-all-concs6359,268935
(defun gen-var-marker (x)gen-var-marker6372,269272
(defun translate-generalize-alist-1 (alist state-vars abbreviations state)translate-generalize-alist-16377,269361
(defun non-gen-var-markers (alist)non-gen-var-markers6432,271446
(defun find-duplicate-generalize-entries (alist var)find-duplicate-generalize-entries6441,271734
(defun translate-generalize-alist-2 (alist avoid-list)translate-generalize-alist-26450,272047
(defun translate-generalize-alist (alist state-vars abbreviations state)translate-generalize-alist6461,272514
(defun all-vars-goals (goals)all-vars-goals6479,273437
(defun pc-state-vars (pc-state)pc-state-vars6486,273692
(define-pc-primitive generalize (&rest args)generalize6490,273877
(define-pc-atomic-macro use (&rest args)use6557,276728
(define-pc-atomic-macro clause-processor (&rest cl-proc-hints)clause-processor6585,277679
(define-pc-macro cl-proc (&rest cl-proc-hints)cl-proc6615,278640
(defun fromto (i j)fromto6624,278893
(define-pc-atomic-macro retain (arg1 &rest rest-args)retain6630,279032
(define-pc-atomic-macro reduce (&rest hints)reduce6664,280162
(define-pc-macro run-instr-on-goal (instr goal-name)run-instr-on-goal6708,281810
(defun run-instr-on-goals-guts (instr goal-names)run-instr-on-goals-guts6719,282066
(define-pc-macro run-instr-on-new-goals (instr existing-goal-namesrun-instr-on-new-goals6726,282315
(define-pc-macro then (instr &optional completion must-succeed-flg)then6739,282782
(defun print-help-separator (state)print-help-separator6764,283628
(defun print-pc-help-rec (lst state)print-pc-help-rec6769,283760
(defun print-all-pc-help-fn (filename state)print-all-pc-help-fn6781,284065
(defmacro print-all-pc-help (&optional filename)print-all-pc-help6797,284748
(define-pc-macro nil ()nil6800,284860
(define-pc-atomic-macro free (var)free6828,285895
(define-pc-macro replay (&optional n replacement-instr)replay6851,286563
(defun instr-name (instr)instr-name6895,288488
(defun pc-free-instr-p (var pc-state)pc-free-instr-p6901,288624
(defun find-possible-put (var state-stack)find-possible-put6906,288793
(define-pc-macro put (var expr)put6918,289279
(define-pc-macro reduce-by-induction (&rest hints)reduce-by-induction6960,291093
(define-pc-macro r (&rest args)r7002,292689
(define-pc-atomic-macro sl (&optional backchain-limit)sl7014,292897
(define-pc-atomic-macro elim ()elim7046,294168
(define-pc-macro ex ()ex7065,294812
(defun save-fc-report-settings ()save-fc-report-settings7080,295131
(defun restore-fc-report-settings ()restore-fc-report-settings7095,295617
(define-pc-help type-alist (&optional concl-flg govs-flg fc-report-flg)type-alist7110,296130
(define-pc-help print-main ()print-main7213,300868
(define-pc-macro pso ()pso7225,301106
(define-pc-macro psog ()psog7245,301815
(define-pc-macro pso! ()pso!7266,302552
(define-pc-macro acl2-wrap (x)acl2-wrap7287,303301
(defmacro acl2-wrap (x)acl2-wrap7303,303664
(define-pc-macro check-proved-goal (goal-name cmd)check-proved-goal7310,303814
(define-pc-macro check-proved (x)check-proved7318,304063
(define-pc-atomic-macro forwardchain (hypn &optional hints quiet-flg)forwardchain7326,304244
(define-pc-atomic-macro bdd (&rest kw-listp)bdd7410,307443
(define-pc-macro runes (&optional flg)runes7434,308269
(define-pc-macro lemmas-used (&optional flg)lemmas-used7455,309079
(defun goal-terms (goals)goal-terms7463,309250
(defun wrap1-aux1 (kept-goal-names all-goals kept-goals removed-goals)wrap1-aux17474,309551
(defun wrap1-aux2 (sym index goals kept-goals removed-goals)wrap1-aux27495,310449
(define-pc-primitive wrap1 (&optional kept-goal-names)wrap17510,311050
(define-pc-atomic-macro wrap (&rest instrs)wrap7589,314364
(define-pc-atomic-macro wrap-induct (&optional raw-term)wrap-induct7635,316321
(define-pc-macro finish-error (instrs)finish-error7667,317238
(define-pc-macro finish (&rest instrs)finish7672,317390
(defun show-geneqv (x with-runes-p)show-geneqv7693,318116
(define-pc-macro geneqv (&optional with-runes-p)geneqv7701,318460
(defun goals-to-clause-list (goals)goals-to-clause-list7735,320169
(defun proof-checker-clause-list (state)proof-checker-clause-list7742,320413
(defun proof-checker-cl-proc (cl instr-list state)proof-checker-cl-proc7745,320489

tutorial.lisp,6702
(deflabel ACL2-TutorialACL2-Tutorial45,1562
(deflabel alternative-introductionalternative-introduction111,4534
(deflabel annotated-acl2-scriptsannotated-acl2-scripts743,34484
(deflabel EmacsEmacs811,37396
(deflabel ACL2-As-Standalone-ProgramACL2-As-Standalone-Program825,37884
(deflabel acl2-sedanacl2-sedan931,40895
(deflabel solution-to-simple-examplesolution-to-simple-example953,41995
(deflabel Tutorial1-Towers-of-HanoiTutorial1-Towers-of-Hanoi1009,43994
(deflabel Tutorial2-Eights-ProblemTutorial2-Eights-Problem1267,53213
(deflabel Tutorial3-Phonebook-ExampleTutorial3-Phonebook-Example1396,57390
(deflabel Tutorial4-Defun-Sk-ExampleTutorial4-Defun-Sk-Example2222,89653
(deflabel Tutorial5-Miscellaneous-ExamplesTutorial5-Miscellaneous-Examples2323,93583
(deflabel file-reading-examplefile-reading-example2333,93863
(deflabel guard-exampleguard-example2389,96296
(deflabel mutual-recursion-proof-examplemutual-recursion-proof-example2699,105463
(deflabel functional-instantiation-examplefunctional-instantiation-example2847,111874
(deflabel StartupStartup2992,116767
(deflabel TidbitsTidbits3077,119678
(deflabel TipsTips3161,123245
(deflabel introduction-to-the-theorem-proverintroduction-to-the-theorem-prover3623,144891
(deflabel dealing-with-key-combinations-of-function-symbolsdealing-with-key-combinations-of-function-symbols3956,161981
(deflabel post-induction-key-checkpointspost-induction-key-checkpoints4138,169870
(deflabel generalizing-key-checkpointsgeneralizing-key-checkpoints4187,172146
(deflabel strong-rewrite-rulesstrong-rewrite-rules4282,176102
(deflabel practice-formulating-strong-rulespractice-formulating-strong-rules4376,180112
(deflabel practice-formulating-strong-rules-1practice-formulating-strong-rules-14440,181923
(deflabel practice-formulating-strong-rules-2practice-formulating-strong-rules-24537,186248
(deflabel practice-formulating-strong-rules-3practice-formulating-strong-rules-34593,188283
(deflabel practice-formulating-strong-rules-4practice-formulating-strong-rules-44720,193178
(deflabel practice-formulating-strong-rules-5practice-formulating-strong-rules-54760,194435
(deflabel practice-formulating-strong-rules-6practice-formulating-strong-rules-64822,196882
(deflabel introduction-to-key-checkpointsintroduction-to-key-checkpoints4930,200841
(deflabel programming-knowledge-taken-for-grantedprogramming-knowledge-taken-for-granted5090,210271
(deflabel example-induction-scheme-nat-recursionexample-induction-scheme-nat-recursion5381,224313
(deflabel example-induction-scheme-down-by-2example-induction-scheme-down-by-25434,225940
(deflabel example-induction-scheme-on-listsexample-induction-scheme-on-lists5492,227619
(deflabel example-induction-scheme-binary-treesexample-induction-scheme-binary-trees5539,228976
(deflabel example-induction-scheme-on-several-variablesexample-induction-scheme-on-several-variables5581,230012
(deflabel example-induction-scheme-upwardsexample-induction-scheme-upwards5627,231015
(deflabel example-induction-scheme-with-accumulatorsexample-induction-scheme-with-accumulators5678,232541
(deflabel example-induction-scheme-with-multiple-induction-stepsexample-induction-scheme-with-multiple-induction-steps5761,235396
(deflabel example-inductionsexample-inductions5825,237168
(deflabel logic-knowledge-taken-for-granted-inductive-prooflogic-knowledge-taken-for-granted-inductive-proof5884,240002
(deflabel logic-knowledge-taken-for-granted-base-caselogic-knowledge-taken-for-granted-base-case6034,247688
(deflabel logic-knowledge-taken-for-granted-q1-answerlogic-knowledge-taken-for-granted-q1-answer6061,248537
(deflabel logic-knowledge-taken-for-granted-q2-answerlogic-knowledge-taken-for-granted-q2-answer6147,252562
(deflabel logic-knowledge-taken-for-granted-q3-answerlogic-knowledge-taken-for-granted-q3-answer6291,257210
(deflabel logic-knowledge-taken-for-granted-instancelogic-knowledge-taken-for-granted-instance6332,258424
(deflabel logic-knowledge-taken-for-granted-propositional-calculuslogic-knowledge-taken-for-granted-propositional-calculus6372,259772
(deflabel logic-knowledge-taken-for-granted-rewritinglogic-knowledge-taken-for-granted-rewriting6620,269105
(deflabel logic-knowledge-taken-for-granted-rewriting-repeatedlylogic-knowledge-taken-for-granted-rewriting-repeatedly6859,279159
(deflabel logic-knowledge-taken-for-granted-equals-for-equalslogic-knowledge-taken-for-granted-equals-for-equals6953,282607
(deflabel logic-knowledge-taken-for-granted-evaluationlogic-knowledge-taken-for-granted-evaluation7004,284514
(deflabel logic-knowledge-taken-for-grantedlogic-knowledge-taken-for-granted7042,285898
(deflabel special-cases-for-rewrite-rulesspecial-cases-for-rewrite-rules7258,294498
(deflabel equivalent-formulas-different-rewrite-rulesequivalent-formulas-different-rewrite-rules7312,296858
(deflabel introduction-to-rewrite-rules-part-2introduction-to-rewrite-rules-part-27385,299806
(deflabel specific-kinds-of-formulas-as-rewrite-rulesspecific-kinds-of-formulas-as-rewrite-rules7624,314121
(deflabel further-information-on-rewritingfurther-information-on-rewriting7711,318450
(deflabel introduction-to-rewrite-rules-part-1introduction-to-rewrite-rules-part-17830,325224
(deflabel introduction-to-the-databaseintroduction-to-the-database8009,334243
(deflabel introduction-to-hintsintroduction-to-hints8241,346169
(deflabel introduction-to-a-few-system-considerationsintroduction-to-a-few-system-considerations8341,351340
(deflabel architecture-of-the-proverarchitecture-of-the-prover8524,360134
(deflabel frequently-asked-questions-by-newcomersfrequently-asked-questions-by-newcomers8605,364191
(deflabel introductory-challengesintroductory-challenges9182,396609
(deflabel introductory-challenge-problem-1introductory-challenge-problem-19218,398161
(deflabel introductory-challenge-problem-1-answerintroductory-challenge-problem-1-answer9251,398972
(deflabel introductory-challenge-problem-2introductory-challenge-problem-29299,400312
(deflabel introductory-challenge-problem-2-answerintroductory-challenge-problem-2-answer9322,400883
(deflabel introductory-challenge-problem-3introductory-challenge-problem-39369,402199
(deflabel introductory-challenge-problem-3-answerintroductory-challenge-problem-3-answer9405,403123
(deflabel introductory-challenge-problem-4introductory-challenge-problem-49524,407128
(deflabel introductory-challenge-problem-4-answerintroductory-challenge-problem-4-answer9581,409400
(deflabel interesting-applicationsinteresting-applications10163,432051
(deflabel advanced-featuresadvanced-features10283,439547

interface-raw.lisp,13165
(defun-*1* mv-list (input-arity x)mv-list676,29373
(defun-*1* return-last (fn x y)return-last680,29447
(defun-*1* wormhole-eval (qname qlambda free-vars)wormhole-eval750,32381
(defun-*1* acl2-numberp (x)acl2-numberp757,32569
(defun-*1* binary-* (x y)binary-*760,32613
(defun-*1* binary-+ (x y)binary-+768,32797
(defun-*1* unary-- (x)unary--779,33071
(defun-*1* unary-/ (x)unary-/785,33180
(defun-*1* < (x y)<791,33309
(defun-*1* apply (x y)apply816,34292
(defun-*1* bad-atom<= (x y)bad-atom<=820,34414
(defun-*1* car (x)car830,34740
(defun-*1* cdr (x)cdr838,34843
(defun-*1* char-code (x)char-code846,34946
(defun-*1* characterp (x)characterp851,35040
(defun-*1* code-char (x)code-char854,35085
(defun-*1* complex (x y)complex861,35236
(defun-*1* complex-rationalp (x)complex-rationalp865,35400
(defun-*1* complexp (x)complexp871,35541
(defun-*1* coerce (x y)coerce874,35582
(defun-*1* cons (x y)cons888,35912
(defun-*1* consp (x)consp891,35949
(defun-*1* denominator (x)denominator894,35984
(defun-*1* equal (x y)equal899,36083
(defun-*1* floor1 (x)floor1903,36147
(defun-*1* if (x y z)if912,36351
(defun-*1* imagpart (x)imagpart917,36552
(defun-*1* integerp (x)integerp922,36640
(defun-*1* intern-in-package-of-symbol (x y)intern-in-package-of-symbol925,36681
(defun-*1* pkg-imports (pkg)pkg-imports931,36863
(defun-*1* pkg-witness (pkg)pkg-witness936,36970
(defun-*1* numerator (x)numerator946,37389
(defun-*1* rationalp (x)rationalp951,37482
(defun-*1* realp (x)realp957,37601
(defun-*1* realpart (x)realpart960,37636
(defun-*1* stringp (x)stringp965,37724
(defun-*1* symbol-name (x)symbol-name968,37763
(defun-*1* symbol-package-name (x)symbol-package-name973,37861
(defun-*1* symbolp (x)symbolp979,38028
(defun standardp (x)standardp995,38669
(defun-*1* standardp (x)standardp999,38719
(defun standard-part (x)standard-part1003,38773
(defun-*1* standard-part (x)standard-part1006,38803
(defun i-large-integer ()i-large-integer1009,38838
(defun-*1* i-large-integer ()i-large-integer1012,38936
(defun-one-output macroexpand1! (x)macroexpand1!1017,39041
(defvar *acl2-gentemp-counter* 0)*acl2-gentemp-counter*1023,39211
(defun-one-output acl2-gentemp (root)acl2-gentemp1024,39245
(defun-one-output oneify-flet-bindings (alist fns w)oneify-flet-bindings1036,39685
(defun-one-output oneify (x fns w)oneify1063,41009
(defun-one-output oneify-lst (lst fns w)oneify-lst1266,48996
(defun-one-output select-stobj (name stobjs terms)select-stobj1274,49191
(defun-one-output super-defstobj-wart-stobjs-in (formals stobj-flag)super-defstobj-wart-stobjs-in1279,49375
(defun-one-output oneify-fail-form (er-type fn formals guard super-stobjs-inoneify-fail-form1287,49712
(defun-one-output get-declared-stobjs (edcls)get-declared-stobjs1308,50421
(defun-one-output warn-for-guard-body (fn)warn-for-guard-body1322,50944
(defun-one-output create-live-user-stobjp-test (stobjs)create-live-user-stobjp-test1334,51529
(defun oneify-cltl-code (defun-mode def stobj-flag wrldoneify-cltl-code1344,51843
(defvar *saved-raw-prompt* nil)*saved-raw-prompt*2088,89063
(defvar *saved-raw-prompt-p* nil)*saved-raw-prompt-p*2089,89095
(defun-one-output install-new-raw-prompt ()install-new-raw-prompt2094,89148
(defun-one-output install-old-raw-prompt ()install-old-raw-prompt2101,89418
(defun-one-output install-new-raw-prompt ()install-new-raw-prompt2111,89685
(defun-one-output install-old-raw-prompt ()install-old-raw-prompt2122,90173
(defun-one-output install-new-raw-prompt ()install-new-raw-prompt2132,90447
(defun-one-output install-old-raw-prompt ()install-old-raw-prompt2139,90678
(defun-one-output install-new-raw-prompt ()install-new-raw-prompt2146,90808
(defun-one-output install-old-raw-prompt ()install-old-raw-prompt2158,91360
(defun-one-output install-new-raw-prompt ()install-new-raw-prompt2172,91852
(defun-one-output install-old-raw-prompt ()install-old-raw-prompt2189,92694
(defun-one-output install-new-raw-prompt ()install-new-raw-prompt2207,93337
(defun-one-output install-old-raw-prompt ()install-old-raw-prompt2210,93389
(defvar *dmr-interval* 1000)*dmr-interval*2223,93743
(defvar *dmr-interval-acl2-par-hack* 300000)*dmr-interval-acl2-par-hack*2224,93772
(defvar *dmr-interval-used*)*dmr-interval-used*2225,93817
(defvar *dmr-indent-max* 20)*dmr-indent-max*2232,94090
(defvar *dmr-file-name*)*dmr-file-name*2238,94374
(defun dmr-file-name ()dmr-file-name2240,94400
(defparameter *dmr-stream**dmr-stream*2253,94998
(defparameter *dmr-counter**dmr-counter*2256,95033
(defun dmr-acl2-par-hack-p ()dmr-acl2-par-hack-p2265,95263
(defun dmr-stop-fn-raw ()dmr-stop-fn-raw2268,95352
(defun initialize-dmr-interval-used ()initialize-dmr-interval-used2274,95481
(defun dmr-start-fn-raw (state)dmr-start-fn-raw2282,95713
(defvar *dmr-array**dmr-array*2296,96178
(defun reverse-into-dmr-array (lst)reverse-into-dmr-array2299,96262
(defparameter *dmr-reusable-string**dmr-reusable-string*2309,96564
(defvar *dmr-indent*)*dmr-indent*2321,96916
(defmacro dmr-increment-indent ()dmr-increment-indent2323,96939
(defun tilde-@-bkptr-string (calling-sys-fn called-sys-fn bkptr)tilde-@-bkptr-string2327,97026
(defvar *dmr-interp-state**dmr-interp-state*2385,99861
(defun dmr-interp-fresh-rewrite-p (calling-sys-fn frame)dmr-interp-fresh-rewrite-p2390,100003
(defun dmr-prefix ()dmr-prefix2397,100216
(defun dmr-interp (i calling-sys-fn frame)dmr-interp2410,100672
(defvar *dmr-delete-string**dmr-delete-string*2485,103412
(defun dmr-string ()dmr-string2491,103528
(defun dmr-flush1 (&optional reset-counter)dmr-flush12575,107292
(defvar *dmr-lock* (make-lock))*dmr-lock*2590,107724
(defun dmr-flush (&optional reset-counter)dmr-flush2592,107757
(defun dmr-display ()dmr-display2604,108192
(defun cw-gstack-short ()cw-gstack-short2616,108569
(defun-one-output fmakunbound! (name)fmakunbound!2771,117320
(defun-one-output maybe-push-undo-stack (fn name &optional extra)maybe-push-undo-stack2778,117589
(defun-one-output maybe-pop-undo-stack (name)maybe-pop-undo-stack2951,125827
(defun-one-output flush-undo-stack (name)flush-undo-stack2964,126168
(defparameter *current-acl2-world-key-ordering**current-acl2-world-key-ordering*3275,142599
(defun-one-output key-lesseqp (key1 key2 ordering)key-lesseqp3299,143328
(defun-one-output merge-into-alist (key val alist)merge-into-alist3308,143604
(defun-one-output destructive-push-assoc (key value alist world-key)destructive-push-assoc3320,144175
(defun-one-output destructive-pop-assoc (key alist)destructive-pop-assoc3337,145045
(defun-one-output remove-current-acl2-world-key (plist)remove-current-acl2-world-key3343,145240
(defun hcomp-init ()hcomp-init4139,190426
(defabbrev reclassifying-value-p (x)reclassifying-value-p4199,193077
(defmacro make-reclassifying-value (x)make-reclassifying-value4206,193230
(defmacro unmake-reclassifying-value (x)unmake-reclassifying-value4212,193360
(defun hcomp-transfer-to-hash-tables ()hcomp-transfer-to-hash-tables4218,193472
(defvar *saved-hcomp-restore-hts* nil)*saved-hcomp-restore-hts*4262,195292
(defun hcomp-restore-defs ()hcomp-restore-defs4264,195332
(defun missing-compiled-book (ctx file reason-msg load-compiled-file state)missing-compiled-book4316,197619
(defun load-compiled-book (file directory-name load-compiled-file ctx state)load-compiled-book4378,200600
(defun include-book-raw (book-name directory-name load-compiled-file dir ctxinclude-book-raw4506,206320
(defun include-book-raw-top (full-book-name directory-name load-compiled-fileinclude-book-raw-top4763,219893
(defmacro hcomp-ht-from-type (type ctx)hcomp-ht-from-type4795,221402
(defmacro hcomp-build-p ()hcomp-build-p4804,221690
(defun install-for-add-trip-hcomp-build (def reclassifyingp evalp)install-for-add-trip-hcomp-build4809,221877
(defun install-for-add-trip-include-book (type name def reclassifyingp)install-for-add-trip-include-book4866,224468
(defun install-for-add-trip (def reclassifyingp evalp)install-for-add-trip4952,228499
(defun install-defs-for-add-trip (defs reclassifying-p wrld declaim-p evalp)install-defs-for-add-trip4968,229138
(defun hcomp-build-from-portcullis-raw (cltl-cmds state)hcomp-build-from-portcullis-raw5088,234699
(defun hcomp-alists-from-hts ()hcomp-alists-from-hts5176,238569
(defun-one-output add-trip (world-name world-key trip)add-trip5221,240428
(defun-one-output undo-trip (world-name world-key trip)undo-trip5789,268590
(defun-one-output flush-trip (name world-key trip)flush-trip5831,270410
(defvar *bad-wrld*)*bad-wrld*5861,271611
(defun check-acl2-world-invariant (wrld old-wrld)check-acl2-world-invariant5863,271632
(defparameter *known-worlds* nil)*known-worlds*5881,272430
(defun update-wrld-structures (wrld state)update-wrld-structures5883,272465
(defun-one-output extend-world1 (name wrld)extend-world15894,272802
(defun-one-output retract-world1 (name wrld)retract-world16007,277962
(defun-one-output recover-world1 (wrld saved-wrld ans)recover-world16108,282353
(defun-one-output recover-world (op name old-wrld universe pkg)recover-world6123,283012
(defun-one-output virginp (name new-type)virginp6251,289634
(defun-one-output chk-virgin2 (name new-type wrld)chk-virgin26262,290020
(defun-one-output chk-package-reincarnation-import-restrictions2chk-package-reincarnation-import-restrictions26329,293242
(defvar user::*acl2-keep-tmp-files* nil)user::*acl2-keep-tmp-files*6368,294478
(defun-one-output enter-boot-strap-mode (system-books-dir operating-system)enter-boot-strap-mode6370,294520
(defun-one-output move-current-acl2-world-key-to-front (wrld)move-current-acl2-world-key-to-front6465,298799
(defun-one-output exit-boot-strap-mode ()exit-boot-strap-mode6554,303406
(defun-one-output ld-alist-raw (standard-oi ld-skip-proofsp ld-error-action)ld-alist-raw6577,304380
(defun enter-boot-strap-pass-2 ()enter-boot-strap-pass-26600,305203
(defconst *acl2-pass-2-files**acl2-pass-2-files*6620,305917
(defun our-update-ht (key val ht)our-update-ht6637,306370
(defun note-fns-in-form (form ht)note-fns-in-form6646,306667
(defun note-fns-in-file (filename ht)note-fns-in-file6735,309850
(defun note-fns-in-files (filenames ht loop-only-p)note-fns-in-files6750,310293
(defun raw-source-name-p (filename-without-extension)raw-source-name-p6763,310864
(defvar *check-built-in-constants-debug* nil)*check-built-in-constants-debug*6770,311145
(defun fns-different-wrt-acl2-loop-only (acl2-files)fns-different-wrt-acl2-loop-only6772,311192
(defun collect-monadic-booleans (fns ens wrld)collect-monadic-booleans6840,314729
(defun check-built-in-constants ()check-built-in-constants6854,315326
(defun-one-output check-none-ideal (trips acc)check-none-ideal7106,326825
(defun check-state-globals-initialized ()check-state-globals-initialized7146,328437
(defun-one-output check-acl2-initialization ()check-acl2-initialization7163,329050
(defun set-initial-cbd ()set-initial-cbd7169,329259
(defun initialize-acl2 (&optional (pass-2-ld-skip-proofsp 'include-book)initialize-acl27197,330400
(defun our-abort (condition your-abort7488,343920
(defun initial-customization-filename ()initial-customization-filename7584,348237
(defun spawn-extra-lispworks-listener ()spawn-extra-lispworks-listener7669,351853
(defun lp (&rest args)lp7695,353056
(defmacro lp! (&rest args)lp!7919,363205
(defun acl2-compile-file (full-book-name os-expansion-filename)acl2-compile-file7925,363372
(defun-one-output delete-auxiliary-book-files (full-book-name)delete-auxiliary-book-files7994,366411
(defun delete-expansion-file (expansion-filename state)delete-expansion-file8027,368093
(defun compile-uncompiled-defuns (file &optional (fns :some) gcl-flgcompile-uncompiled-defuns8035,368386
(defun compile-uncompiled-*1*-defuns (file &optional (fns :some) gcl-flg chan0compile-uncompiled-*1*-defuns8215,376717
(defun compile-certified-file (expansion-filename full-book-name state)compile-certified-file8451,387908
(defun compile-for-include-book (full-book-name certified-p ctx state)compile-for-include-book8465,388514
(defun-one-output enabled-structurep (x)enabled-structurep8532,391958
(defun-one-output rcnstp (x)rcnstp8555,392945
(defvar *trace-alist**trace-alist*8571,393359
(defun-one-output assoc-eq-trace-alist (val alist)assoc-eq-trace-alist8574,393426
(defun-one-output print-list-without-stobj-arrays (lst)print-list-without-stobj-arrays8582,393651
(defun-one-output stobj-print-symbol (x user-stobj-alist-tail)stobj-print-symbol8589,393850
(defun-one-output trace-hide-world-and-state (l)trace-hide-world-and-state8606,394605
(defun-one-output saved-build-date-string ()saved-build-date-string8660,396854
(defun-one-output get-stobjs-out-for-declare-form (fn)get-stobjs-out-for-declare-form8671,397150
(defun fix-trace-untrace (new-trace-specs old-trace-specs)fix-trace-untrace8696,398125
(defun fix-trace (old-trace-specs)fix-trace8708,398565
(defun acl2-books-revision ()acl2-books-revision8720,399057

defpkgs.lisp,90
(defconst *acl2-exports**acl2-exports*34,1565
(defpkg "ACL2-USER""ACL2-USER"638,27417

boot-strap-pass-2.lisp,3623
(defattach too-many-ifs-post-rewrite too-many-ifs-post-rewrite-builtin)too-many-ifs-post-rewrite487,19522
(defthm fn-count-evg-rec-type-prescriptionfn-count-evg-rec-type-prescription524,20788
(defthm fn-count-evg-rec-boundfn-count-evg-rec-bound529,20942
(defthm fn-count-1-typefn-count-1-type546,21393
(defthm symbol-listp-cdr-assoc-equalsymbol-listp-cdr-assoc-equal571,22588
(defthm integerp-nth-0-var-fn-count-1integerp-nth-0-var-fn-count-1579,22915
(defthm integerp-nth-1-var-fn-count-1integerp-nth-1-var-fn-count-1606,24205
(defthm integerp-nth-2-var-fn-count-1integerp-nth-2-var-fn-count-1629,25266
(defun member-equal-mod-commuting (x lst wrld)member-equal-mod-commuting660,26527
(defun strip-ancestor-literals (ancestors)strip-ancestor-literals673,27135
(defattach worse-than worse-than-builtin)worse-than756,30389
(defattach worse-than-or-equal worse-than-or-equal-builtin)worse-than-or-equal758,30432
(defattach rw-cache-debug rw-cache-debug-builtin)rw-cache-debug779,31047
(defattach rw-cache-debug-action rw-cache-debug-action-builtin)rw-cache-debug-action783,31174
(defattach rw-cacheable-failure-reason rw-cacheable-failure-reason-builtin)rw-cacheable-failure-reason787,31321
(defthm d-pos-listp-forward-to-true-listpd-pos-listp-forward-to-true-listp812,32089
(defattach print-clause-id-okp print-clause-id-okp-builtin)print-clause-id-okp829,32654
(defattach oncep-tp oncep-tp-builtin)oncep-tp863,33895
(defthm pos-listp-forward-to-integer-listppos-listp-forward-to-integer-listp885,34833
(defthm true-listp-chars-for-tilde-@-clause-id-phrase/periodstrue-listp-chars-for-tilde-@-clause-id-phrase/periods892,35035
(defthm true-listp-explode-atomtrue-listp-explode-atom896,35198
(deftheory definition-minimal-theorydefinition-minimal-theory991,38048
(deftheory executable-counterpart-minimal-theoryexecutable-counterpart-minimal-theory997,38158
(deftheory minimal-theoryminimal-theory1003,38285
(deftheory ground-zero (current-theory :here)ground-zero1053,40237
(defund meta-extract-formula (name state)meta-extract-formula1084,41170
(defun typespec-check (ts x)typespec-check1111,42319
(defun meta-extract-rw+-term (term alist equiv rhs state)meta-extract-rw+-term1123,42693
(defun meta-extract-contextual-fact (obj mfc state)meta-extract-contextual-fact1154,43840
(defun rewrite-rule-term (x)rewrite-rule-term1199,45908
(defmacro meta-extract-global-fact (obj state)meta-extract-global-fact1213,46340
(defun fncall-term (fn arglist state)fncall-term1217,46473
(defun logically-equivalent-states (st1 st2)logically-equivalent-states1234,47115
(defun meta-extract-global-fact+ (obj st state)meta-extract-global-fact+1238,47230
(defun pair-fns-with-measured-subsets (fns wrld acc)pair-fns-with-measured-subsets1295,49630
(defun new-verify-guards-fns1 (wrld installed-wrld acc)new-verify-guards-fns11312,50422
(defun new-verify-guards-fns (state)new-verify-guards-fns1334,51448
(defconst *system-verify-guards-alist**system-verify-guards-alist*1345,51890
(defconst *len-system-verify-guards-alist**len-system-verify-guards-alist*1402,53746
(defmacro chk-new-verified-guards (n)chk-new-verified-guards1405,53831
(defun system-verify-guards-fn-1 (fns-alist acc)system-verify-guards-fn-11439,55325
(defun cons-absolute-event-numbers (fns-alist wrld acc)cons-absolute-event-numbers1452,55934
(defun sort->-absolute-event-number (fns-alist wrld)sort->-absolute-event-number1469,56679
(defun system-verify-guards-fn (alist wrld acc)system-verify-guards-fn1474,56897
(defmacro system-verify-guards ()system-verify-guards1484,57250

hons-raw.lisp,9768
(defmacro hl-without-interrupts (&rest forms)hl-without-interrupts94,4387
(defun hl-mht-fn (&key (test             'eql)hl-mht-fn104,4685
(defvar *allegro-hl-hash-table-size-ht**allegro-hl-hash-table-size-ht*127,5524
(defmacro hl-mht (&rest args)hl-mht131,5637
(defabbrev hl-static-cons (a b)hl-static-cons217,9570
(defabbrev hl-staticp (x)hl-staticp221,9643
(defabbrev hl-static-inverse-cons (x)hl-static-inverse-cons225,9705
(defabbrev hl-machine-address-of (x)hl-machine-address-of231,9793
(defabbrev hl-machine-hash (x)hl-machine-hash235,9869
(defconstant hl-cache-table-sizehl-cache-table-size381,17111
(defconstant hl-cache-table-cutoffhl-cache-table-cutoff386,17198
(defstruct hl-cachehl-cache390,17333
(defun hl-cache-set (key val cache)hl-cache-set402,17687
(defun hl-cache-get (key cache)hl-cache-get427,18622
(defun hl-cache-clear (cache)hl-cache-clear454,19377
(defparameter *hl-hspace-str-ht-default-size*      1000)*hl-hspace-str-ht-default-size*672,29220
(defparameter *hl-ctables-nil-ht-default-size*     5000)*hl-ctables-nil-ht-default-size*673,29277
(defparameter *hl-ctables-cdr-ht-default-size*     100000)*hl-ctables-cdr-ht-default-size*674,29334
(defparameter *hl-ctables-cdr-ht-eql-default-size* 1000)*hl-ctables-cdr-ht-eql-default-size*675,29393
(defparameter *hl-hspace-addr-ht-default-size*     150000)*hl-hspace-addr-ht-default-size*676,29450
(defparameter *hl-hspace-sbits-default-size*       16000000)*hl-hspace-sbits-default-size*677,29509
(defparameter *hl-hspace-other-ht-default-size*    1000)*hl-hspace-other-ht-default-size*678,29570
(defparameter *hl-hspace-fal-ht-default-size*      1000)*hl-hspace-fal-ht-default-size*679,29627
(defparameter *hl-hspace-persist-ht-default-size*  100)*hl-hspace-persist-ht-default-size*680,29684
(defstruct hl-ctableshl-ctables685,29757
(defun hl-initialize-faltable-table (fal-ht-size)hl-initialize-faltable-table702,30323
(defstruct hl-falslothl-falslot743,32434
(defun hl-faltable-init (&key (size *hl-hspace-fal-ht-default-size*))hl-faltable-init789,34103
(defun hl-hspace-init (&key (str-ht-size       *hl-hspace-str-ht-default-size*)hl-hspace-init845,35701
(defabbrev hl-flex-alist-too-long (x)hl-flex-alist-too-long927,39535
(defabbrev hl-flex-assoc (key al)hl-flex-assoc943,40137
(defabbrev hl-flex-acons (elem al)hl-flex-acons953,40433
(defun hl-hspace-truly-static-honsp (x hs)hl-hspace-truly-static-honsp995,41938
(defabbrev hl-hspace-find-alist-for-cdr (b ctables)hl-hspace-find-alist-for-cdr1010,42478
(defun hl-hspace-honsp (x hs)hl-hspace-honsp1030,43204
(defun hl-hspace-honsp-wrapper (x)hl-hspace-honsp-wrapper1048,43671
(defun hl-hspace-faltable-wrapper ()hl-hspace-faltable-wrapper1054,43865
(defun hl-hspace-normedp (x hs)hl-hspace-normedp1061,44063
(defun hl-hspace-normedp-wrapper (x)hl-hspace-normedp-wrapper1082,44609
(defun hl-hspace-hons-equal-lite (x y hs)hl-hspace-hons-equal-lite1095,45008
(defun hl-hspace-hons-equal (x y hs)hl-hspace-hons-equal1115,45579
(defconstant hl-minimum-static-inthl-minimum-static-int1191,48564
(defconstant hl-maximum-static-inthl-maximum-static-int1196,48704
(defconstant hl-num-static-intshl-num-static-ints1201,48840
(defconstant hl-dynamic-base-addrhl-dynamic-base-addr1206,49023
(defconstant hl-static-int-shifthl-static-int-shift1215,49312
(ccl::defstatic *hl-symbol-addr-lock**hl-symbol-addr-lock*1223,49701
(defabbrev hl-symbol-addr (s)hl-symbol-addr1228,49866
(defun hl-addr-of-unusual-atom (x str-ht other-ht)hl-addr-of-unusual-atom1276,52072
(defmacro hl-addr-of (x str-ht other-ht)hl-addr-of1319,53771
(defun hl-nat-combine* (a b)hl-nat-combine*1342,54677
(defabbrev hl-addr-combine* (a b)hl-addr-combine*1356,55235
(defparameter *hl-addr-limit-minimum**hl-addr-limit-minimum*1436,59175
(defun hl-make-addr-limit-current (hs)hl-make-addr-limit-current1444,59500
(defun hl-make-addr-limit-next (hs)hl-make-addr-limit-next1457,59930
(defun hl-addr-ht-fullness (hs)hl-addr-ht-fullness1475,60686
(defparameter *hl-addr-limit-should-clear-memo-tables**hl-addr-limit-should-clear-memo-tables*1481,60909
(defun hl-addr-limit-action (hs)hl-addr-limit-action1486,61029
(defun hl-hspace-grow-sbits (idx hs)hl-hspace-grow-sbits1546,63512
(defun hl-hspace-norm-atom (x hs)hl-hspace-norm-atom1590,65758
(defun hl-hspace-hons-normed (a b hint hs)hl-hspace-hons-normed1628,67077
(defun hl-hspace-norm-aux (x cache hs)hl-hspace-norm-aux1782,74804
(defun hl-hspace-norm-expensive (x hs)hl-hspace-norm-expensive1808,75744
(defun hl-hspace-norm (x hs)hl-hspace-norm1826,76379
(defun hl-hspace-persistent-norm (x hs)hl-hspace-persistent-norm1835,76600
(defabbrev hl-hspace-hons (x y hs)hl-hspace-hons1860,77637
(defun hl-slow-alist-warning (name)hl-slow-alist-warning1963,82184
(defun hl-faltable-maphash (f faltable)hl-faltable-maphash1981,82949
(defun hl-faltable-load-empty-slot (alist slot faltable)hl-faltable-load-empty-slot2008,83814
(defun hl-faltable-eject (slot faltable)hl-faltable-eject2031,84701
(defun hl-faltable-get-free-slot (faltable)hl-faltable-get-free-slot2049,85385
(defun hl-faltable-slot-lookup (alist faltable)hl-faltable-slot-lookup2064,85952
(defun hl-faltable-general-lookup (alist faltable)hl-faltable-general-lookup2091,86984
(defun hl-faltable-remove (alist faltable)hl-faltable-remove2106,87639
(defun hl-hspace-fast-alist-free (alist hs)hl-hspace-fast-alist-free2129,88655
(defun hl-hspace-hons-get (key alist hs)hl-hspace-hons-get2137,88859
(defun hl-hspace-hons-acons (key value alist hs)hl-hspace-hons-acons2163,89892
(defun hl-alist-stolen-warning (name)hl-alist-stolen-warning2223,92336
(defun hl-hspace-hons-acons! (key value alist hs)hl-hspace-hons-acons!2241,93090
(defun hl-alist-longest-normed-tail (alist hs)hl-alist-longest-normed-tail2290,95037
(defun hl-make-fast-norm-keys (alist tail hs)hl-make-fast-norm-keys2310,95834
(defun hl-make-fast-alist-put-pairs (alist ht)hl-make-fast-alist-put-pairs2336,96811
(defun hl-hspace-make-fast-alist (alist hs)hl-hspace-make-fast-alist2352,97468
(defun hl-shrink-alist-aux-really-slow (alist ans honsp hs)hl-shrink-alist-aux-really-slow2404,99855
(defun hl-shrink-alist-aux-slow (alist ans table honsp hs)hl-shrink-alist-aux-slow2426,100853
(defun hl-shrink-alist-aux-fast (alist ans table honsp hs)hl-shrink-alist-aux-fast2452,102038
(defun hl-hspace-shrink-alist (alist ans honsp hs)hl-hspace-shrink-alist2483,103415
(defun hl-hspace-fast-alist-len (alist hs)hl-hspace-fast-alist-len2557,106773
(defun hl-check-alist-for-serialize-restore (alist hs)hl-check-alist-for-serialize-restore2576,107497
(defun hl-hspace-restore-fal-for-serialize (alist count hs)hl-hspace-restore-fal-for-serialize2595,108169
(defun hl-restore-fal-for-serialize (alist count)hl-restore-fal-for-serialize2621,109413
(defun hl-hspace-number-subtrees-aux (x seen)hl-hspace-number-subtrees-aux2632,109807
(defun hl-hspace-number-subtrees (x hs)hl-hspace-number-subtrees2644,110141
(defun hl-system-gc ()hl-system-gc2671,111057
(defun hl-hspace-classic-restore (x nil-ht cdr-ht cdr-ht-eql seen-ht)hl-hspace-classic-restore2690,111601
(defun hl-hspace-hons-clear (gc hs)hl-hspace-hons-clear2746,113988
(defun hl-hspace-static-restore (x addr-ht sbits str-ht other-ht)hl-hspace-static-restore2826,117298
(defun hl-hspace-hons-clear (gc hs)hl-hspace-hons-clear2868,119129
(defun hl-fix-sbits-after-gc (sbits)hl-fix-sbits-after-gc2958,122869
(defun hl-rebuild-addr-ht (sbits addr-ht str-ht other-ht)hl-rebuild-addr-ht2979,123673
(defparameter *hl-addr-ht-resize-cutoff**hl-addr-ht-resize-cutoff*3016,125485
(defun hl-hspace-hons-wash (hs)hl-hspace-hons-wash3024,125858
(defun hl-maybe-resize-ht (size src)hl-maybe-resize-ht3172,132728
(defun hl-hspace-resize (str-ht-size nil-ht-size cdr-ht-size cdr-ht-eql-sizehl-hspace-resize3200,133895
(defun hl-get-final-cdr (alist)hl-get-final-cdr3277,136717
(defun hl-hspace-fast-alist-summary (hs)hl-hspace-fast-alist-summary3282,136818
(defun hl-hspace-hons-summary (hs)hl-hspace-hons-summary3325,138597
(defparameter *default-hs**default-hs*3409,141756
(defun hl-maybe-initialize-default-hs ()hl-maybe-initialize-default-hs3439,142903
(defun hl-maybe-initialize-default-hs-wrapper ()hl-maybe-initialize-default-hs-wrapper3446,143043
(defun hons (x y)hons3450,143167
(defun hons-copy (x)hons-copy3455,143303
(defun hons-copy-persistent (x)hons-copy-persistent3460,143440
(defun hons-equal (x y)hons-equal3466,143607
(defun hons-equal-lite (x y)hons-equal-lite3472,143812
(defun hons-summary ()hons-summary3477,143997
(defun hons-clear (gc)hons-clear3482,144120
(defun hons-wash ()hons-wash3487,144244
(defun hons-resize-fn (str-ht nil-ht cdr-ht cdr-ht-eqlhons-resize-fn3492,144361
(defun hons-acons (key val fal)hons-acons3504,144782
(defun hons-acons! (key val fal)hons-acons!3510,144999
(defun hons-shrink-alist (alist ans)hons-shrink-alist3515,145187
(defun hons-shrink-alist! (alist ans)hons-shrink-alist!3520,145338
(defun hons-get (key fal)hons-get3526,145516
(defun fast-alist-free (fal)fast-alist-free3532,145723
(defun fast-alist-len (fal)fast-alist-len3538,145942
(defun number-subtrees (x)number-subtrees3544,146159
(defun fast-alist-summary ()fast-alist-summary3549,146340
(defun make-fast-alist (alist)make-fast-alist3554,146475
(defmacro with-fast-alist-raw (alist form)with-fast-alist-raw3559,146615
(defmacro with-stolen-alist-raw (alist form)with-stolen-alist-raw3588,147847
(defmacro fast-alist-free-on-exit-raw (alist form)fast-alist-free-on-exit-raw3617,149106
(defun clear-hash-tables ()clear-hash-tables3624,149295
(defun wash-memory ()wash-memory3629,149409

memoize-raw.lisp,12915
(defconstant most-positive-mfixnum (1- (expt 2 60)))most-positive-mfixnum69,2711
(deftype mfixnum ()mfixnum71,2765
(defmacro our-syntax (&rest args)our-syntax86,3276
(defmacro our-syntax-nice (&rest args)our-syntax-nice112,4228
(defmacro our-syntax-brief (&rest args)our-syntax-brief122,4588
(defmacro ofn (&rest r) ; For forming strings.ofn131,4813
(defun-one-output ofnum (n) ; For forming numbers.ofnum134,4895
(defmacro ofni (&rest r) ; For forming symbols in package ACL2.ofni145,5220
(defmacro ofnm (&rest r) ; For forming uninterned symbols.ofnm148,5343
(defmacro oft (&rest r) ; For writing to *standard-output*.oft151,5451
(defmacro oftr (&rest r) ; For writing to *trace-output*.oftr155,5582
(defv *number-of-arguments-and-values-ht**number-of-arguments-and-values-ht*165,5858
(defun-one-output input-output-number-error (fn)input-output-number-error208,7395
(defun-one-output number-of-arguments (fn)number-of-arguments218,7889
(defun-one-output number-of-return-values (fn)number-of-return-values242,8711
(defg *float-ticks/second* 1.0)*float-ticks/second*265,9496
(defg *float-internal-time-units-per-second**float-internal-time-units-per-second*267,9529
(defabbrev internal-real-time ()internal-real-time273,9712
(defun-one-output float-ticks/second-init ()float-ticks/second-init281,10037
(defun-one-output safe-incf-aux-error (x inc where)safe-incf-aux-error303,10770
(defmacro safe-incf-aux (x inc where)safe-incf-aux307,10912
(defmacro safe-incf (x inc &optional where)safe-incf338,12083
(defparameter *count-pons-calls* t*count-pons-calls*384,13857
(defg *pons-call-counter* 0)*pons-call-counter*390,14101
(defg *pons-misses-counter* 0)*pons-misses-counter*391,14130
(defmacro maybe-count-pons-calls ()maybe-count-pons-calls395,14254
(defmacro maybe-count-pons-misses ()maybe-count-pons-misses399,14384
(defun-one-output assoc-no-error-at-end (x l)assoc-no-error-at-end403,14518
(defun-one-output too-long (x n)too-long419,15062
(defconstant atom-case-fudge (+ 129 (expt 2 25)))atom-case-fudge432,15669
(defconstant most-positive-fudge (1- (expt 2 24)))most-positive-fudge433,15719
(defconstant most-negative-fudge (- (expt 2 24)))most-negative-fudge434,15770
(defconstant -most-negative-fudge (- most-negative-fudge))-most-negative-fudge435,15820
(defun-one-output atom-case (s)atom-case438,15890
(defmacro sqmpf ()sqmpf457,16642
(defmacro hmnf ()hmnf460,16694
(defmacro static-hons-shift ()static-hons-shift466,16784
(defun-one-output addr-for (x y)addr-for470,16883
(defun-one-output pons (x y ht)pons529,19370
(defmacro pist* (table &rest x)pist*608,21885
(defvar *never-memoize-ht**never-memoize-ht*624,22514
(defun never-memoize-fn (fn)never-memoize-fn981,31074
(defun never-memoize-p (fn)never-memoize-p984,31148
(defparameter *record-bytes**record-bytes*1008,31947
(defparameter *record-calls* t*record-calls*1016,32267
(defparameter *record-hits* t*record-hits*1020,32389
(defparameter *record-hons-calls* t*record-hons-calls*1025,32564
(defparameter *record-mht-calls* t*record-mht-calls*1029,32690
(defparameter *record-pons-calls* t*record-pons-calls*1034,32891
(defparameter *record-time* t*record-time*1038,33029
(defv *report-bytes* #+Clozure t #-Clozure nil*report-bytes*1045,33216
(defv *report-calls* t*report-calls*1049,33372
(defv *report-calls-from* t*report-calls-from*1053,33477
(defv *report-calls-to* t*report-calls-to*1058,33649
(defv *report-hits* t*report-hits*1063,33829
(defv *report-hons-calls* t*report-hons-calls*1067,33977
(defv *report-mht-calls* t*report-mht-calls*1071,34118
(defv *report-pons-calls* t*report-pons-calls*1079,34537
(defv *report-time* t*report-time*1083,34660
(defv *report-on-memo-tables* t*report-on-memo-tables*1087,34794
(defv *report-on-pons-tables* t*report-on-pons-tables*1091,34927
(defg *memoize-info-ht**memoize-info-ht*1095,35060
(defrec memoize-info-ht-entrymemoize-info-ht-entry1106,35365
(defg *memoize-call-array**memoize-call-array*1150,37312
(defg *compute-array* (make-array 0)*compute-array*1182,39001
(defv *initial-max-memoize-fns* 500)*initial-max-memoize-fns*1199,39519
(defg *2max-memoize-fns* (* 2 *initial-max-memoize-fns*))*2max-memoize-fns*1201,39557
(defconstant *ma-bytes-index*       0)*ma-bytes-index*1203,39616
(defconstant *ma-hits-index*        1)*ma-hits-index*1204,39655
(defconstant *ma-mht-index*         2)*ma-mht-index*1205,39694
(defconstant *ma-hons-index*        3)*ma-hons-index*1206,39733
(defconstant *ma-pons-index*        4)*ma-pons-index*1207,39772
(defconstant *ma-initial-max-symbol-to-fixnum* 4)*ma-initial-max-symbol-to-fixnum*1209,39812
(defg *max-symbol-to-fixnum* *ma-initial-max-symbol-to-fixnum*)*max-symbol-to-fixnum*1211,39863
(defg *caller* (* *ma-initial-max-symbol-to-fixnum* *2max-memoize-fns*)*caller*1219,40116
(defn memoize-here-come (n)memoize-here-come1226,40372
(defun memoize-flush1 (lst)memoize-flush11269,42182
(defmacro memoize-flush (st)memoize-flush1287,43060
(defparameter *memo-max-sizes**memo-max-sizes*1298,43227
(defrec memo-max-sizes-entrymemo-max-sizes-entry1315,44018
(defun make-initial-memoize-hash-table (fn init-size)make-initial-memoize-hash-table1325,44466
(defun make-initial-memoize-pons-table (fn init-size)make-initial-memoize-pons-table1376,47107
(defun update-memo-max-sizes (fn pt-size mt-size)update-memo-max-sizes1409,48917
(defun print-memo-max-sizes ()print-memo-max-sizes1438,50455
(defmacro heap-bytes-allocated ()heap-bytes-allocated1470,51885
(defn sync-memoize-call-array ()sync-memoize-call-array1473,51967
(defun memoize-call-array-growmemoize-call-array-grow1498,52887
(defun-one-output symbol-to-fixnum-create (s)symbol-to-fixnum-create1527,54231
(defun-one-output symbol-to-fixnum (s)symbol-to-fixnum1551,55195
(defun-one-output fixnum-to-symbol (n)fixnum-to-symbol1557,55411
(defun-one-output coerce-index (x)coerce-index1562,55570
(defun-one-output memoize-eval-compile (def)memoize-eval-compile1575,55744
(defun-one-output memoizedp-raw (fn)memoizedp-raw1584,56012
(defg *hons-gentemp-counter* 0)*hons-gentemp-counter*1588,56119
(defun-one-output hons-gentemp (root)hons-gentemp1590,56152
(defun-one-output st-lst (st)st-lst1599,56482
(defun-one-output dcls (l)dcls1611,56858
(defg *assoc-eq-hack-ht* (hl-mht :test 'eql))*assoc-eq-hack-ht*1624,57268
(defn assoc-eq-hack (x y)assoc-eq-hack1627,57357
(defun abbrev (x &optionalabbrev1640,57916
(defun prine (obj &optional stream)prine1664,58924
(defun prine-alist (obj &optional stream)prine-alist1669,59055
(defun-one-output mf-trace-exit (fn nrv ans)mf-trace-exit1701,60100
(defg *memoize-fn-signature-error**memoize-fn-signature-error*1711,60419
(defg *sort-to-from-by-calls* nil)*sort-to-from-by-calls*1720,60798
(defvar *memoize-use-attachment-warning-p* t)*memoize-use-attachment-warning-p*1722,60834
(defun memoize-use-attachment-warning (fn at-fn)memoize-use-attachment-warning1724,60881
(defun-one-output memoize-fn-suffix (str sym)memoize-fn-suffix1751,62322
(defun-one-output mis-ordered-commutative-args (x y)mis-ordered-commutative-args1759,62547
(defun our-function-lambda-expression (sym)our-function-lambda-expression1787,63706
(defun memoize-look-up-def (fn cl-defun inline wrld)memoize-look-up-def1795,64033
(defun fix-time (ticks ctx)fix-time1838,65802
(defg *memoize-init-done* nil)*memoize-init-done*1848,66137
(defun memoize-fn (fn &key (condition t) (inline t) (trace nil)memoize-fn1850,66169
(defun-one-output unmemoize-fn (fn)unmemoize-fn2520,97360
(defun-one-output maybe-unmemoize (fn)maybe-unmemoize2570,99447
(defun-one-output memoized-functions ()memoized-functions2582,99969
(defun-one-output length-memoized-functions ()length-memoized-functions2592,100258
(defun-one-output unmemoize-all ()unmemoize-all2601,100542
(defun-one-output memoize-info (k)memoize-info2616,101082
(defun-one-output rememoize-all ()rememoize-all2662,103092
(defun-one-output uses-state (fn)uses-state2684,103755
(defun profile-fn (fn &rest r &key (condition nil) (inline nil)profile-fn2693,104117
(defun-one-output profiled-functions ()profiled-functions2700,104315
(defun-one-output unmemoize-profiled ()unmemoize-profiled2715,104756
(defmacro memoize-on-raw (fn x)memoize-on-raw2726,105044
(defmacro memoize-off-raw (fn x)memoize-off-raw2739,105557
(defun-one-output memoize-condition (fn)memoize-condition2752,106066
(defn global-restore-memoize ()global-restore-memoize2758,106227
(defg *memoize-summary-order-list**memoize-summary-order-list*2768,106505
(defg *memoize-summary-limit* 20*memoize-summary-limit*2799,107361
(defg *shorten-ht* (hl-mht :test 'eql))*shorten-ht*2805,107569
(defn shorten (x n)shorten2807,107610
(defg *memoize-summary-order-reversed* nil*memoize-summary-order-reversed*2836,108918
(defg *print-alist-width* 45)*print-alist-width*2842,109125
(defun-one-output print-alist (alist separation)print-alist2844,109156
(defmacro very-unsafe-incf (x inc &rest r)very-unsafe-incf2874,110228
(defmacro very-very-unsafe-aref-incf (ar loc)very-very-unsafe-aref-incf2888,110563
(defun-one-output pons-summary ()pons-summary2894,110776
(defun memoized-values (&optional (fn (memoized-functions)))memoized-values2935,112365
(defn print-call-stack ()print-call-stack2957,113200
(defun-one-output hons-calls (x)hons-calls2992,114429
(defun-one-output pons-calls (x)pons-calls3005,114798
(defun-one-output bytes-allocated (x)bytes-allocated3018,115165
(defun-one-output number-of-hits (x)number-of-hits3030,115560
(defun-one-output number-of-memoized-entries (x)number-of-memoized-entries3042,115952
(defun-one-output number-of-mht-calls (x)number-of-mht-calls3057,116446
(defun-one-output time-for-non-hits/call (x)time-for-non-hits/call3069,116847
(defun-one-output time/call (x)time/call3074,117021
(defun-one-output hits/calls (x)hits/calls3079,117159
(defun-one-output bytes-allocated/call (x)bytes-allocated/call3085,117320
(defn char-list-fraction (l)char-list-fraction3092,117488
(defn symbol-name-order (s)symbol-name-order3098,117619
(defun-one-output execution-order (s)execution-order3106,117844
(defn compute-calls-and-times ()compute-calls-and-times3116,118138
(defun-one-output number-of-calls (x)number-of-calls3159,120075
(defun-one-output print-not-called ()print-not-called3168,120318
(defun-one-output total-time (x)total-time3185,120875
(defn lex-> (l1 l2)lex->3196,121145
(defun-one-output memoize-summary-sort ()memoize-summary-sort3204,121337
(defun-one-output memoize-summary ()memoize-summary3223,121960
(defg *short-symbol-name-width* 30)*short-symbol-name-width*3299,124961
(defn short-symbol-name (sym)short-symbol-name3301,124998
(defun-one-output outside-p (x)outside-p3310,125322
(defun-one-output memoize-summary-after-compute-calls-and-times ()memoize-summary-after-compute-calls-and-times3314,125447
(defun-one-output empty-ht-p (x)empty-ht-p3629,139953
(defn clear-one-memo-and-pons-hash (l)clear-one-memo-and-pons-hash3633,140066
(defun-one-output clear-memoize-table (k)clear-memoize-table3657,141209
(defun-one-output clear-memoize-tables ()clear-memoize-tables3666,141396
(defn clear-memoize-call-array ()clear-memoize-call-array3681,141773
(defn clear-memoize-statistics ()clear-memoize-statistics3691,142102
(defun-one-output memoize-init ()memoize-init3696,142174
(defg *max-mem-usage* (expt 2 32)*max-mem-usage*3735,143460
(defg *gc-min-threshold* (expt 2 30)*gc-min-threshold*3743,143705
(defun-one-output set-gc-threshold (bound)set-gc-threshold3751,143837
(defmacro globlet (bindings &rest rest)globlet3760,144046
(defmacro globlet (&rest r)globlet3790,145282
(defmacro with-lower-overhead (&rest r)with-lower-overhead3801,145612
(defun acl2h-init-memoizations ()acl2h-init-memoizations3827,146708
(defun acl2h-init-unmemoizations ()acl2h-init-unmemoizations3864,148058
(defun looking-at (str1 str2 &key (start1 0) (start2 0))looking-at3893,149126
(defun meminfo (pat)meminfo3921,150184
(defvar *sol-gc-installed* nil)*sol-gc-installed*3956,151474
(defun set-and-reset-gc-thresholds ()set-and-reset-gc-thresholds3960,151518
(defun start-sol-gc ()start-sol-gc3983,152422
(defun-one-output acl2h-init ()acl2h-init4078,156295
(defun memstat (&rest r)memstat4177,160125
(defmacro memo-on (&rest r)memo-on4180,160182
(defmacro memo-off (&rest r)memo-off4183,160232
(defun clear-memo-tables (&rest r)clear-memo-tables4186,160284
(defn lower-overhead ()lower-overhead4193,160422
(defun our-gctime ()our-gctime4210,160895
(defun update-memo-entry-for-attachments (fns entry wrld)update-memo-entry-for-attachments4213,160978
(defun update-memo-entries-for-attachments (fns wrld state)update-memo-entries-for-attachments4235,161911

multi-threading-raw.lisp,3613
(defmacro without-interrupts (&rest forms)without-interrupts68,2994
(defmacro unwind-protect-disable-interrupts-during-cleanupunwind-protect-disable-interrupts-during-cleanup91,3890
(defun make-atomically-modifiable-counter (initial-value)make-atomically-modifiable-counter151,6759
(defmacro define-atomically-modifiable-counter (name initial-value)define-atomically-modifiable-counter161,6998
(defmacro atomically-modifiable-counter-read (counter)atomically-modifiable-counter-read164,7138
(defmacro atomic-incf (x)atomic-incf174,7342
(defmacro atomic-incf-multiple (counter count)atomic-incf-multiple209,8732
(defmacro atomic-decf (x)atomic-decf237,9909
(defun lockp (x)lockp261,10910
(defun make-lock (&optional lock-name)make-lock273,11297
(defmacro reset-lock (bound-symbol)reset-lock302,12540
(defmacro with-lock (bound-symbol &rest forms)with-lock312,12897
(defun run-thread (name fn-symbol &rest args)run-thread335,13668
(defun interrupt-thread (thread function &rest args)interrupt-thread370,15022
(defun kill-thread (thread)kill-thread390,15718
(defun all-threads ()all-threads402,15977
(defun current-thread ()current-thread412,16209
(defun thread-wait (fn &rest args)thread-wait422,16387
(defmacro with-potential-timeout (body &key timeout)with-potential-timeout437,16980
(defun make-condition-variable ()make-condition-variable532,21197
(defmacro signal-condition-variable (cv)signal-condition-variable551,21762
(defmacro broadcast-condition-variable (cv)broadcast-condition-variable580,22863
(defun wait-on-condition-variable (cv lock &key timeout)wait-on-condition-variable592,23152
(defstruct acl2-semaphoreacl2-semaphore627,24633
(defstruct acl2-semaphoreacl2-semaphore633,24772
(defun make-semaphore (&optional name)make-semaphore638,24893
(defun semaphorep (semaphore)semaphorep695,27666
(defun make-semaphore-notification ()make-semaphore-notification722,28667
(defun semaphore-notification-status (semaphore-notification-object)semaphore-notification-status737,29143
(defun clear-semaphore-notification-status (semaphore-notification-object)clear-semaphore-notification-status754,29787
(defun set-semaphore-notification-status (semaphore-notification-object)set-semaphore-notification-status771,30525
(defun signal-semaphore (semaphore)signal-semaphore780,30877
(defun wait-on-semaphore (semaphore &key notification timeout)wait-on-semaphore807,31791
(defvar *throwable-worker-thread**throwable-worker-thread*929,37533
(defun throw-all-threads-in-list (thread-list)throw-all-threads-in-list943,38210
(defun kill-all-threads-in-list (thread-list)kill-all-threads-in-list991,40264
(defun thread-name (thread)thread-name1003,40635
(defconstant *worker-thread-name* "Worker thread")*worker-thread-name*1013,40876
(defun worker-threads1 (threads)worker-threads11015,40928
(defun worker-threads ()worker-threads1023,41190
(defun all-worker-threads-are-dead ()all-worker-threads-are-dead1030,41351
(defun all-given-threads-are-reset (threads)all-given-threads-are-reset1037,41473
(defun all-worker-threads-are-dead-or-reset ()all-worker-threads-are-dead-or-reset1044,41682
(defun send-die-to-worker-threads ()send-die-to-worker-threads1056,42093
(defun kill-all-worker-threads ()kill-all-worker-threads1088,43418
(defun core-count-raw (&optional (ctx nil) default)core-count-raw1103,43915
(defvar *core-count**core-count*1123,44653
(defvar *unassigned-and-active-work-count-limit**unassigned-and-active-work-count-limit*1131,44892
(defconstant *max-idle-thread-count**max-idle-thread-count*1149,45854

futures-raw.lisp,6148
(defstruct st-futurest-future49,1893
(defmacro st-future (x)st-future59,2101
(defun st-future-read (st-future)st-future-read69,2471
(defun st-future-abort (st-future)st-future-abort83,3032
(defstruct atomic-notificationatomic-notification199,6821
(defstruct barrierbarrier218,7691
(defun broadcast-barrier (barrier)broadcast-barrier243,8941
(defun wait-on-barrier (barrier)wait-on-barrier256,9451
(defstruct mt-futuremt-future266,9779
(define-atomically-modifiable-counter *last-slot-saved* 0)*last-slot-saved*277,10024
(define-atomically-modifiable-counter *last-slot-taken* 0)*last-slot-taken*278,10083
(defvar *future-array*)*future-array*295,11068
(defvar *thread-array*)*thread-array*296,11092
(defvar *future-dependencies*)*future-dependencies*297,11116
(defparameter *future-queue-length-history**future-queue-length-history*299,11148
(defvar *current-thread-index**current-thread-index*305,11241
(defconstant *starting-core* 'start)*starting-core*312,11416
(defconstant *resumptive-core* 'resumptive)*resumptive-core*313,11453
(defvar *allocated-core**allocated-core*315,11498
(defvar *decremented-idle-future-thread-count* nil)*decremented-idle-future-thread-count*338,12667
(defvar *idle-future-core-count**idle-future-core-count*340,12720
(defvar *idle-future-resumptive-core-count**idle-future-resumptive-core-count*342,12806
(defvar *idle-core* (make-semaphore))*idle-core*344,12908
(define-atomically-modifiable-counter *idle-future-thread-count**idle-future-thread-count*346,12947
(defvar *future-added* (make-semaphore))*future-added*365,14032
(defvar *idle-resumptive-core* (make-semaphore))*idle-resumptive-core*367,14074
(defvar *threads-spawned* 0)*threads-spawned*370,14142
(define-atomically-modifiable-counter *unassigned-and-active-future-count**unassigned-and-active-future-count*372,14172
(define-atomically-modifiable-counter *total-future-count**total-future-count*382,14524
(defconstant *future-array-size* 200000)*future-array-size*394,14967
(defmacro faref (array subscript)faref396,15009
(defvar *resource-and-timing-based-parallelizations**resource-and-timing-based-parallelizations*403,15243
(defvar *resource-and-timing-based-serializations**resource-and-timing-based-serializations*408,15429
(defvar *resource-based-parallelizations**resource-based-parallelizations*413,15618
(defvar *resource-based-serializations**resource-based-serializations*418,15782
(defun reset-future-queue-length-history ()reset-future-queue-length-history423,15949
(defun reset-future-parallelism-variables ()reset-future-parallelism-variables426,16038
(defun reset-all-parallelism-variables ()reset-all-parallelism-variables498,18678
(defun futures-parallelism-buffer-has-space-available ()futures-parallelism-buffer-has-space-available505,18992
(defun not-too-many-futures-already-in-existence ()not-too-many-futures-already-in-existence512,19257
(defun futures-resources-available ()futures-resources-available556,21331
(defmacro unwind-protect-disable-interrupts-during-cleanupunwind-protect-disable-interrupts-during-cleanup574,22240
(define-atomically-modifiable-counter *threads-waiting-for-starting-core**threads-waiting-for-starting-core*596,23131
(defun claim-starting-core ()claim-starting-core607,23615
(defun claim-resumptive-core ()claim-resumptive-core631,24705
(defun free-allocated-core ()free-allocated-core669,26043
(defun early-terminate-children (index)early-terminate-children691,26850
(defvar *aborted-futures-via-flag* 0)*aborted-futures-via-flag*706,27452
(defvar *aborted-futures-total* 0)*aborted-futures-total*707,27490
(defvar *futures-resources-available-count* 0)*futures-resources-available-count*710,27545
(defvar *futures-resources-unavailable-count* 0)*futures-resources-unavailable-count*711,27592
(defun set-thread-check-for-abort-and-funcall (future)set-thread-check-for-abort-and-funcall713,27642
(defvar *throwable-future-worker-thread**throwable-future-worker-thread*762,29825
(defun wait-for-a-closure ()wait-for-a-closure778,30433
(defvar *busy-wait-var* 0)*busy-wait-var*860,35369
(defvar *current-waiting-thread* nil)*current-waiting-thread*861,35396
(defvar *fresh-waiting-threads* 0)*fresh-waiting-threads*862,35434
(defun make-tclet-thrown-symbol1 (tags first-tag)make-tclet-thrown-symbol1867,35579
(defun make-tclet-thrown-symbol (tags)make-tclet-thrown-symbol878,35896
(defun make-tclet-bindings1 (tags)make-tclet-bindings1881,35990
(defun make-tclet-bindings (tags)make-tclet-bindings888,36178
(defun make-tclet-thrown-tags1 (tags)make-tclet-thrown-tags1891,36264
(defun make-tclet-thrown-tags (tags)make-tclet-thrown-tags897,36433
(defun make-tclet-catches (rtags body thrown-tag-bindings)make-tclet-catches900,36525
(defun make-tclet-cleanups (thrown-tags cleanups)make-tclet-cleanups910,36891
(defmacro throw-catch-let (tags body cleanups)throw-catch-let918,37143
(defun eval-a-closure ()eval-a-closure989,39646
(defun eval-closures ()eval-closures1044,42000
(defun number-of-idle-threads-and-threads-waiting-for-a-starting-core ()number-of-idle-threads-and-threads-waiting-for-a-starting-core1079,43152
(defun spawn-closure-consumers ()spawn-closure-consumers1088,43455
(defun make-future-with-closure (closure)make-future-with-closure1122,45285
(defun add-future-to-queue (future)add-future-to-queue1162,47400
(defmacro mt-future (x)mt-future1174,47732
(defun mt-future-read (future)mt-future-read1265,51772
(defvar *aborted-futures-via-throw* 0)*aborted-futures-via-throw*1312,53815
(defvar *almost-aborted-future-count* 0)*almost-aborted-future-count*1313,53854
(defun mt-future-abort (future)mt-future-abort1315,53896
(defun abort-future-indices (indices)abort-future-indices1387,57344
(defun print-non-nils-in-array (array n)print-non-nils-in-array1401,57856
(defun futures-still-in-flight ()futures-still-in-flight1410,58135
(defmacro future (x)future1422,58485
(defun future-read (x)future-read1425,58526
(defun future-abort (x)future-abort1428,58572
(defun abort-futures (futures)abort-futures1431,58620

parallel-raw.lisp,4364
(defstruct parallelism-piece ; piece of workparallelism-piece213,9963
(defparameter *reset-parallelism-variables* nil)*reset-parallelism-variables*348,16353
(defparameter *reset-core-count-too**reset-core-count-too*350,16403
(defun reset-parallelism-variables ()reset-parallelism-variables360,16828
(defun eval-and-save-result (work)eval-and-save-result422,18939
(defun pop-work-and-set-thread ()pop-work-and-set-thread440,19673
(defun consume-work-on-work-queue-when-there ()consume-work-on-work-queue-when-there471,21080
(defun spawn-worker-threads-if-needed ()spawn-worker-threads-if-needed617,28131
(defun add-work-list-to-queue (work-list)add-work-list-to-queue661,30311
(defun combine-array-results-into-list (result-array current-position acc)combine-array-results-into-list685,31421
(defun remove-thread-array-from-work-queue-recremove-thread-array-from-work-queue-rec695,31745
(defun remove-thread-array-from-work-queue (thread-array)remove-thread-array-from-work-queue729,33013
(defun terminate-siblings (thread-array)terminate-siblings738,33336
(defun generate-work-list-from-closure-list-recgenerate-work-list-from-closure-list-rec751,33974
(defun generate-work-list-from-closure-listgenerate-work-list-from-closure-list771,34835
(defun pargs-parallelism-buffer-has-space-available ()pargs-parallelism-buffer-has-space-available799,35995
(defun not-too-many-pieces-of-parallelism-work-already-in-existence ()not-too-many-pieces-of-parallelism-work-already-in-existence803,36176
(defun parallelism-resources-available ()parallelism-resources-available814,36751
(defun throw-threads-in-array (thread-array current-position)throw-threads-in-array832,37681
(defun decrement-children-left (children-left-ptr semaphore-notification-obj)decrement-children-left861,39140
(defun wait-for-children-to-finishwait-for-children-to-finish869,39459
(defun wait-for-resumptive-parallelism-resources ()wait-for-resumptive-parallelism-resources887,40210
(defun early-terminate-children-and-rewaitearly-terminate-children-and-rewait907,41150
(defun prepare-to-wait-for-children ()prepare-to-wait-for-children940,42428
(defun parallelize-closure-list (closure-list &optional terminate-early-function)parallelize-closure-list959,43169
(defun parallelize-fn (parent-fun-name arg-closures &optional terminate-early-function)parallelize-fn1069,48024
(defmacro closure-for-expression (x)closure-for-expression1085,48731
(defmacro closure-list-for-expression-list (x)closure-list-for-expression-list1088,48799
(defun parallelism-condition (gran-form-exists gran-form)parallelism-condition1097,49082
(defmacro pargs (&rest forms)pargs1107,49401
(defun plet-doublets (bindings bsym n)plet-doublets1127,50104
(defun make-closures (bindings)make-closures1134,50313
(defun identity-list (&rest rst) rst)identity-list1147,50810
(defun make-list-until-non-declare (remaining-list acc)make-list-until-non-declare1149,50849
(defun parse-additional-declare-forms-for-let (x)parse-additional-declare-forms-for-let1155,51114
(defmacro plet (&rest forms)plet1165,51510
(defmacro pand (&rest forms)pand1189,52475
(defmacro por (&rest forms)por1210,53261
(defun signal-semaphores (sems)signal-semaphores1232,54030
(defmacro spec-mv-let (bindings computation body)spec-mv-let1238,54184
(defun number-of-active-threads-aux (threads acc)number-of-active-threads-aux1277,55525
(defun number-of-active-threads ()number-of-active-threads1289,55865
(defun number-of-threads-waiting-on-a-child-aux (threads acc)number-of-threads-waiting-on-a-child-aux1292,55951
(defun number-of-threads-waiting-on-a-child ()number-of-threads-waiting-on-a-child1304,56335
(defun future-queue-length ()future-queue-length1307,56445
(defun total-number-of-threads ()total-number-of-threads1325,57206
(defvar *refresh-rate-indicator* 0)*refresh-rate-indicator*1328,57267
(defmacro value-of-symbol (var)value-of-symbol1330,57304
(defun acl2p-sum-list1 (lst acc)acl2p-sum-list11344,57930
(defun acl2p-sum-list (lst)acl2p-sum-list1350,58086
(defun average-future-queue-size ()average-future-queue-size1357,58241
(defun print-interesting-parallelism-variables-str ()print-interesting-parallelism-variables-str1361,58391
(defun print-interesting-parallelism-variables ()print-interesting-parallelism-variables1420,60474

serialize-raw.lisp,3484
(defparameter *ser-verbose* nil)*ser-verbose*269,12198
(defmacro ser-time? (form)ser-time?271,12232
(defmacro ser-print? (msg &rest args)ser-print?276,12314
(defmacro ser-write-char (x stream)ser-write-char290,12862
(defmacro ser-write-byte (x stream)ser-write-byte293,12943
(defmacro ser-read-char (stream)ser-read-char296,13048
(defmacro ser-read-byte (stream)ser-read-byte301,13275
(defun ser-encode-magic (stream)ser-encode-magic304,13373
(defun ser-decode-magic (stream)ser-decode-magic311,13607
(defun ser-encode-nat-fixnum (n stream)ser-encode-nat-fixnum371,16345
(defun ser-encode-nat-large (n stream)ser-encode-nat-large387,16885
(defmacro ser-encode-nat (n stream)ser-encode-nat405,17568
(defun ser-decode-nat-large (shift value stream)ser-decode-nat-large417,17885
(defmacro ser-decode-nat-body (shift)ser-decode-nat-body435,18544
(defun ser-decode-nat (stream)ser-decode-nat469,19951
(defun ser-encode-rat (x stream)ser-encode-rat498,20874
(defun ser-decode-rat (stream)ser-decode-rat504,21070
(defun ser-encode-complex (x stream)ser-encode-complex533,22164
(defun ser-decode-complex (stream)ser-decode-complex538,22310
(defun ser-encode-str (x stream)ser-encode-str564,23389
(defun ser-decode-str (version hons-mode stream)ser-decode-str573,23727
(defstruct ser-decoderser-decoder605,24863
(defun ser-encode-nats (x stream)ser-encode-nats624,25485
(defun ser-decode-and-load-nats (decoder stream)ser-decode-and-load-nats631,25686
(defun ser-encode-rats (x stream)ser-encode-rats651,26435
(defun ser-decode-and-load-rats (decoder stream)ser-decode-and-load-rats658,26637
(defun ser-encode-complexes (x stream)ser-encode-complexes677,27321
(defun ser-decode-and-load-complexes (decoder stream)ser-decode-and-load-complexes684,27532
(defun ser-encode-chars (x stream)ser-encode-chars703,28217
(defun ser-decode-and-load-chars (decoder stream)ser-decode-and-load-chars710,28421
(defun ser-encode-strs (x stream)ser-encode-strs729,29094
(defun ser-decode-and-load-strs (hons-mode decoder stream)ser-decode-and-load-strs736,29294
(defun ser-encode-package (pkg x stream)ser-encode-package780,31261
(defun ser-decode-and-load-package (check-packagesp decoder stream)ser-decode-and-load-package789,31570
(defun ser-encode-packages (alist stream)ser-encode-packages817,32914
(defun ser-decode-and-load-packages (check-packagesp decoder stream)ser-decode-and-load-packages825,33238
(defun ser-hashtable-init (size test)ser-hashtable-init841,33776
(defstruct ser-encoderser-encoder854,34211
(defmacro ser-see-obj (x table)ser-see-obj924,37257
(defun ser-gather-atoms (x encoder)ser-gather-atoms934,37510
(defun ser-make-atom-map (encoder)ser-make-atom-map1070,43758
(defun ser-encode-consesser-encode-conses1178,48408
(defmacro ser-decode-loop (version hons-mode)ser-decode-loop1230,50856
(defun ser-decode-and-load-conses (hons-mode decoder stream)ser-decode-and-load-conses1267,52419
(defun ser-encode-fals (encoder)ser-encode-fals1355,56706
(defun ser-decode-and-restore-fals (decoder hons-mode stream)ser-decode-and-restore-fals1383,57845
(defun ser-encode-atoms (encoder)ser-encode-atoms1410,59185
(defun ser-encode-to-stream (obj stream)ser-encode-to-stream1425,59808
(defun ser-decode-and-load-atoms (check-packagesp hons-mode decoder stream)ser-decode-and-load-atoms1498,62752
(defun ser-decode-from-stream (check-packagesp hons-mode stream)ser-decode-from-stream1508,63170
